nsresult
HTMLScriptElement::SetAsync(bool aValue)
{
ErrorResult rv;
SetAsync(aValue, rv);
return rv.StealNSResult();
}
void DOM_SuspendCallbackBase::SuspendESThread(DOM_Runtime* origining_runtime)
{
OP_ASSERT(origining_runtime);
SetAsync();
m_thread = DOM_Object::GetCurrentThread(origining_runtime);
OP_ASSERT(m_thread);
m_thread->AddListener(this);
m_thread->Block();
}
void CTCPSocketAsync::Accepted()
{
try
{
//Add to async list
AddSocketToList();
//Go to async mode
SetAsync();
}
ERROR_HANDLER("CTCPSocketAsync")
}
BOOL CTCPSocketAsync::LocalConnect(unsigned short usSourcePort,
IP aDestinationAddress,
unsigned short usDestinationPort,
BOOL bDisableAsync,
BOOL bForceErrorEvent)
{
try
{
//Quit if not ok
if (!CheckSocketValid())
return FALSE;
//Set the async notification
if (!bDisableAsync)
{
int iResult;
iResult=InternalWSAAsyncSelect(WM_SOCKET_CONNECT,
FD_CONNECT);
if (iResult)
{
//Get the error code
int iErrorCode;
iErrorCode=GetSystemLastError();
//Report it
SetLastError("Connect");
//Do we need to call event?
if (bForceErrorEvent)
SocketConnected(iErrorCode);
//Exit
return FALSE;
}
//Set our timeout
if (m_ulTimeout &&
!IsBlocking())
if (!SetSystemTimeout(m_ulTimeout))
{
//Report it
ReportError("LocalConnect","Failed to set timer!");
//Do we need to call event?
if (bForceErrorEvent)
SocketConnected(GetErrorCode());
//Exit
return FALSE;
}
}
//Set to non blocking!
else if (!Block())
return FALSE;
//Set the flag
m_bDisabledConnect=bDisableAsync;
//Call the original connect
BOOL bResult;
bResult=CTCPSocket::Connect(usSourcePort,
aDestinationAddress,
usDestinationPort);
//Reset the flag
m_bDisabledConnect=FALSE;
if (bResult)
{
//Call event, but only if in async
if (!bDisableAsync &&
!IsBlocking())
//Call user, will add socket automatically
return SocketConnected(0);
else
//Set as async
return SetAsync();
}
else if (GetSystemLastError()!=WSAEWOULDBLOCK ||
bDisableAsync ||
IsBlocking())
{
if (m_ulTimeout)
//Kill the timer
KillSystemTimer();
//Get the error code
int iErrorCode;
iErrorCode=GetSystemLastError();
//Report it
SetLastError("Connect");
//Do we need to call event?
if (bForceErrorEvent &&
!bDisableAsync)
SocketConnected(iErrorCode);
//Exit
return FALSE;
}
else
return TRUE;
}
ERROR_HANDLER_RETURN("LocalConnect",FALSE)
}
BOOL CUDPSocketAsync::OnSocketConnect(int iErrorCode)
{
//First set async again
return SetAsync();
}
// ----------------------------------------------------------------------------
// Message dispatcher
// ----------------------------------------------------------------------------
//
void CMPXPlaybackSession::DispatchMessageL( const RMessage2& aMessage, TInt& aMsgHandleResult )
{
aMsgHandleResult = KErrNone;
//
// All methods apart from the player creation methods, require a player
//
TInt op=aMessage.Function();
if (op != EPbsSetMode)
{
CheckPlayerL();
}
MPX_DEBUG3("-->CMPXPlaybackSession::DispatchMessageL %d, this 0x%08x",
op, this);
switch(op)
{
case EPbsSetMode:
{
SetModeL(aMessage);
break;
}
case EPbsGetClients:
{
RArray<TProcessId> procArray;
::CopyArrayL<TProcessId>(
iPlayer->ClientList()->ClientProcessList(),
procArray );
TProcessId lastPid = static_cast<CMPXPlaybackServer*>(
const_cast<CServer2*>(Server()))->LastActiveProcessId();
TInt index( procArray.Find( lastPid ));
if ( KErrNotFound != index && index )
{
procArray.Remove( index );
procArray.Insert( lastPid, 0 );
}
::CreateBufferL<TProcessId>(
procArray.Array(),
iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
procArray.Close();
break;
}
case EPbsGetSyncBuffer:
{
aMessage.WriteL(0,iSyncBuffer->Ptr(0));
delete iSyncBuffer;
iSyncBuffer = NULL;
break;
}
case EPbsGetAsyncBuffer:
{
//In case of other application leaving, causing us to leave
//we could have a task that does not get removed from the top of the queue
//but the data for that task has been deleted.
//When the task runs again, there will be no data causing a panic - leave if this occurs
User::LeaveIfNull(iAsyncBuffer);
aMessage.WriteL(0,iAsyncBuffer->Ptr(0));
delete iAsyncBuffer;
iAsyncBuffer = NULL;
break;
}
case EPbsInitFromCollection:
{
MPXUser::CreateBufferL(aMessage, 0, iSyncBuffer);
CMPXCollectionPlaylist* p = NULL;
::NewFromBufferL(*iSyncBuffer, p);
delete iSyncBuffer;
iSyncBuffer = NULL;
CleanupStack::PushL(p);
iPlayer->InitL(*p,aMessage.Int1());
CleanupStack::PopAndDestroy(p);
}
break;
case EPbsInitFromUri:
{
CBufBase* buf0(NULL);
MPXUser::CreateBufferL(aMessage,0,buf0);
CleanupStack::PushL(buf0);
// Type parameter is optional
if ( aMessage.GetDesLength( 1 ) > 0 )
{
CBufBase* buf1(NULL);
MPXUser::CreateBufferL(aMessage,1,buf1);
CleanupStack::PushL(buf1);
iPlayer->InitL(MPXUser::Ptr(buf0->Ptr(0)), buf1->Ptr(0));
CleanupStack::PopAndDestroy(buf1);
}
else
{
MPX_DEBUG2("CMPXPlaybackSession::DispatchMessageL %d: Type is empty", op);
iPlayer->InitL( MPXUser::Ptr( buf0->Ptr(0) ), KNullDesC8 );
}
CleanupStack::PopAndDestroy(buf0);
}
break;
case EPbsInitFromFile:
{
InitFromFileL(aMessage);
break;
}
case EPbsInitStreamingFromUri:
{
CBufBase* buf0(NULL);
MPXUser::CreateBufferL(aMessage,0,buf0);
CleanupStack::PushL(buf0);
// Type parameter is optional
if ( aMessage.GetDesLength( 1 ) > 0 )
{
CBufBase* buf1(NULL);
MPXUser::CreateBufferL(aMessage,1,buf1);
CleanupStack::PushL(buf1);
iPlayer->InitStreamingL(MPXUser::Ptr(buf0->Ptr(0)), buf1->Ptr(0), aMessage.Int2());
CleanupStack::PopAndDestroy(buf1);
}
else
{
MPX_DEBUG2("CMPXPlaybackSession::DispatchMessageL %d: Type is empty", op);
iPlayer->InitStreamingL( MPXUser::Ptr( buf0->Ptr(0) ), KNullDesC8, aMessage.Int2() );
}
CleanupStack::PopAndDestroy(buf0);
break;
}
case EPbsInitStreamingFromFile:
{
RFile file;
User::LeaveIfError(file.AdoptFromClient(aMessage,0,1));
iPlayer->InitStreamingL(file, aMessage.Int2());
file.Close();
break;
}
case EPbsCancelRequest:
{
CancelRequests();
break;
}
case EPbsGetState:
{
aMsgHandleResult = iPlayer->State();
break;
}
case EPbsSetProperty:
{
iPlayer->SetL(static_cast<TMPXPlaybackProperty>(aMessage.Int0()),
aMessage.Int1());
break;
}
case EPbsGetProperty:
{
SetAsync(aMessage);
iPlayer->PropertyL(
static_cast<TMPXPlaybackProperty>(aMessage.Int0()),*this);
break;
}
case EPbsGetPlayerTypes:
{
RArray<TMPXPlaybackPlayerType> pluginTypes;
CleanupClosePushL(pluginTypes);
RArray<TInt> types;
CleanupClosePushL(types);
iPlayer->PluginHandler()->GetPluginTypes(types);
for (TInt i=0; i< types.Count(); ++i)
{
pluginTypes.AppendL(
static_cast<TMPXPlaybackPlayerType>(types[i]));
}
CleanupStack::PopAndDestroy(&types);
::CreateBufferL<TMPXPlaybackPlayerType>(
pluginTypes.Array(),
iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
CleanupStack::PopAndDestroy(&pluginTypes);
break;
}
case EPbsGetPlayerTypeDisplayName:
{
const TDesC& playerName = iPlayer->PluginHandler()->PlayerName(
static_cast<TMPXPlaybackPlayerType>(aMessage.Int0()));
aMsgHandleResult = 0;
if (playerName.Length()>0)
{
MPXUser::CreateBufferL(playerName, iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
}
break;
}
case EPbsGetAllPlayersUids:
{
RArray<TUid> uids;
CleanupClosePushL(uids);
iPlayer->PluginHandler()->GetPluginUids(uids);
::CreateBufferL<TUid>(
uids.Array(),
iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
CleanupStack::PopAndDestroy(&uids);
break;
}
case EPbsGetPlayersUidsForType:
{
aMsgHandleResult = CreatePlayerUidsBufferL(aMessage);
break;
}
case EPbsGetSubPlayerNamesByUid:
{
SetAsync(aMessage);
iPlayer->SubPlayerNamesL(TUid::Uid(aMessage.Int0()),*this);
break;
}
case EPbsSelectPlayerByType:
{
iPlayer->PluginHandler()->SelectPlayersL(
static_cast<TMPXPlaybackPlayerType>(aMessage.Int0()));
break;
}
case EPbsSelectPlayerByUid:
{
iPlayer->PluginHandler()->SelectPlayerL(TUid::Uid(aMessage.Int0()));
break;
}
case EPbsSelectSubPlayer:
{
iPlayer->PluginHandler()->SelectSubPlayerL(
TUid::Uid(aMessage.Int0()),aMessage.Int1());
break;
}
case EPbsClearPlayerSelection:
{
iPlayer->PluginHandler()->ClearSelectPlayersL();
break;
}
case EPbsGetSelection:
{
GetSelectionL(aMessage);
break;
}
case EPbsPlayerFound:
{
aMsgHandleResult = iPlayer->PluginHandler()->PlayerFound();
break;
}
case EPbsGetPlayerType:
{
aMsgHandleResult = iPlayer->PluginHandler()->PluginType();
break;
}
case EPbsGetTypeName:
{
MPXUser::CreateBufferL(iPlayer->PluginHandler()->PlayerName(),
iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
break;
}
case EPbsGetSubPlayerIndex:
{
aMsgHandleResult = iPlayer->PluginHandler()->SubPlayer();
break;
}
case EPbsGetPlayerUid:
{
TPckgC<TInt> uidPkg((iPlayer->PluginHandler()->PluginUid()).iUid);
aMessage.Write(0,uidPkg);
break;
}
case EPbsGetCollectionPlaylist:
{
aMsgHandleResult = 0;
if (iPlayer->Playlist())
{
::CreateBufferL<CMPXCollectionPlaylist>(*(iPlayer->Playlist()),
iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
}
break;
}
case EPbsGetFile:
{
const RFile& file = iPlayer->File();
if (file.SubSessionHandle())
{
aMsgHandleResult = file.TransferToClient(aMessage,0); //message completed
}
else
{
TPckgC<TInt> handle(KErrNotFound);
aMessage.Write(0, handle);
}
break;
}
case EPbsGetUri:
{
aMsgHandleResult=0;
if (iPlayer->Uri().Length()>0)
{
MPXUser::CreateBufferL(iPlayer->Uri(),iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
}
break;
}
case EPbsGetMedia:
{
SetAsync( aMessage );
CMPXCommand* cmd( CMPXCommand::NewL( aMessage.Int1() ) );
CleanupStack::PushL( cmd );
iPlayer->MediaL( *this, *cmd );
CleanupStack::PopAndDestroy( cmd );
break;
}
case EPbsGetSupportedMimeTypes:
{
CDesCArray* mimeTypes =
iPlayer->PluginHandler()->SupportedMimeTypesL();
CleanupStack::PushL(mimeTypes);
MPXUser::CreateBufferL((const MDesCArray*)mimeTypes, iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
CleanupStack::PopAndDestroy(mimeTypes);
}
break;
case EPbsGetSupportedExtensions:
{
CDesCArray* exts =
iPlayer->PluginHandler()->SupportedExtensionsL();
CleanupStack::PushL(exts);
MPXUser::CreateBufferL((const MDesCArray*)exts, iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
CleanupStack::PopAndDestroy(exts);
}
break;
case EPbsGetSupportedSchemas:
{
CDesCArray* schemas =
iPlayer->PluginHandler()->SupportedSchemasL();
CleanupStack::PushL(schemas);
MPXUser::CreateBufferL((const MDesCArray*)schemas, iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
CleanupStack::PopAndDestroy(schemas);
}
break;
case EPbsGetNextMessage:
{
ASSERT(iMessageQueue);
iMessageQueue->SendNext(aMessage);
iCompleteRequest=EFalse;
break;
}
case EPbsCancelGetMessage:
{
ASSERT(iMessageQueue);
iMessageQueue->Reset();
break;
}
case EPbsCommand:
{
CMPXCommand* cmd( NULL );
::NewFromMessageL<CMPXMedia>(aMessage, 1, cmd);
CleanupStack::PushL(cmd);
iPlayer->CommandL(*cmd, *iMessageQueue);
CleanupStack::PopAndDestroy(cmd);
break;
}
#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
case EPbsInitFromFile64:
{
RFile64 file;
User::LeaveIfError(file.AdoptFromClient(aMessage,0,1));
iPlayer->Init64L(file);
file.Close();
break;
}
case EPbsInitStreamingFromFile64:
{
RFile64 file;
User::LeaveIfError(file.AdoptFromClient(aMessage,0,1));
iPlayer->InitStreaming64L(file, aMessage.Int2());
file.Close();
break;
}
case EPbsGetFile64:
{
const RFile64& file = iPlayer->File64();
if (file.SubSessionHandle())
{
aMsgHandleResult = file.TransferToClient(aMessage,0); //message completed
}
else
{
TPckgC<TInt> handle(KErrNotFound);
aMessage.Write(0, handle);
}
break;
}
#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
case EPbsSetPrimaryClient:
{
aMsgHandleResult = iPlayer->ClientList()->SetPrimaryClient(*iMessageQueue);
break;
}
default:
{
PanicClient(aMessage,KErrNotSupported);
break;
}
}
MPX_DEBUG1("<---CMPXPlaybackSession::DispatchMessageL");
}
