/*
* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: API functions that were loaded into TLS for the Browser to use.
*
*/
// INCLUDE FILES
#include <Uri16.h>
#include <mmf/common/MmfControllerFrameworkBase.h>
#include "stdlib.h"
#include "BavpLogger.h"
#include "BavpPlugin.h"
#include "BavpVolumeHandler.h"
#include <npscript.h>
#include "BavpNPObject.h"
// CONSTANTS
_LIT(KAccessPtId, "accesspointid");
_LIT(KLoop,"loop");
_LIT(KSrc,"src");
_LIT(KData,"data");
_LIT(KRtsp,"rtsp");
_LIT(KInfinite,"infinite");
_LIT(KVolume, "volume");
_LIT(KHigh, "high");
_LIT(KMiddle, "middle");
_LIT(KLow, "low");
const TInt KOneLoopValue = 1;
const TInt KMaxLoopValue = 50;
// ============================= LOCAL FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// BavpNewp
// Create a new instance of a plugin. This is non-leaving method.
// Returns: NPError: Error codes recognized by Browser
// -----------------------------------------------------------------------------
NPError BavpNewp( NPMIMEType /* pluginType*/, // Not used locally
NPP aInstance, // Stores pointer to Bavp
uint16 /* mode */, //
CDesCArray* argn, // The number of arguments passed
CDesCArray* argv, // The values of arguments in the array
NPSavedData* /*saved*/ ) //
{
// Fix for TSW error ID: SLON-74588K, as ControlPanel is unsupported so for the time being
// controlPanel plugin window shown as emplty non supported window.
_LIT(KControls, "controls");
_LIT(KControlPanel, "controlpanel");
for ( TInt i=0; i < argn->Count(); i++ )
{
if(((*argn)[i].Compare( KControls) == 0)&&((*argv)[i].Compare(KControlPanel ) == 0))
{
return NPERR_INVALID_PLUGIN_ERROR;
}
}
// Create BrowserAudioVideoPlugin, call this leaving method to wrap leaving methods
TRAPD( err, BavpConstructL( aInstance, argn, argv ) );
if ( err == KErrNoMemory )
{
Log( EFalse, _L("FUNCTION BavpNewp ERROR! Out of Memory Error") );
return NPERR_OUT_OF_MEMORY_ERROR;
}
if ( err != KErrNone )
{
Log( EFalse, _L("FUNCTION BavpNewp ERROR! Module Load Failure") );
return NPERR_MODULE_LOAD_FAILED_ERROR;
}
return NPERR_NO_ERROR;
}
// -----------------------------------------------------------------------------
// BavpConstructL
// This is the leaving method to create the plugin. We have leaving setters
// that need to be wrapped.
// Returns: void
// -----------------------------------------------------------------------------
void BavpConstructL( NPP aInstance, // Stores pointer to Bavp
CDesCArray* argn, // The number of arguments passed
CDesCArray* argv ) // The values of arguments in the array
{
Log( EFalse, _L("Calling FUNCTION BavpConstructL") );
CBavpPlugin *pluginInstance( NULL );
// Create BrowserVideoPlugin
pluginInstance = CBavpPlugin::NewL();
// Bavp functions can now be called
aInstance->pdata = pluginInstance;
// Retrieve the various attributes from the HTTP file and the
// object/embed/bgsound/soundstart tags on that page
//
// Retrieve the access point attribute
TInt accessPtIndex;
TInt accessPtId( KUseDefaultIap );
if ( !argn->Find( KAccessPtId, accessPtIndex, ECmpFolded ) )
{
// If the string is found get the access pt id and convert to TInt
TPtrC16 accessPtValue( (*argv)[accessPtIndex] );
TLex lex( accessPtValue );
TInt intVal( 0 );
if ( lex.Val( intVal ) == KErrNone)
{
accessPtId = intVal;
}
}
pluginInstance->SetAccessPtId( accessPtId );
// Retrieve the "loop" attribute value, default value is "1",
// with infiniteFlag off. This handles the loop attribute missing
// and loop="0" cases.
TInt loopIndex( 0 );
TPtrC16 loopValue;
TBool infiniteFlag( EFalse ); // Always false, use loop="50" instead "infinite"
TInt loop( KOneLoopValue ); // Our default loop value is "1"
TInt positionLoop = argn->Find( KLoop, loopIndex, ECmpFolded );
if ( positionLoop == 0 )
{
// Found a loop attribute value
TPtrC16 pointerLoopCount( (*argv)[loopIndex] );
loopValue.Set( pointerLoopCount );
// Is the loop value equal to string "infinite"
if ( loopValue.Compare( KInfinite ) == 0 )
{
// We never play true infinite, we loop max 50 times
loop = KMaxLoopValue;
}
else
{
// Ensure that only a valid loop value is used (1 to 50)
HBufC8* convertPointerLoopCount = HBufC8::New( pointerLoopCount.Length() );
TPtr8 convertToByteLoop = convertPointerLoopCount->Des();
convertToByteLoop.Copy( pointerLoopCount );
loop = atoi( (char*)(convertToByteLoop.Ptr()) );
if ( loop < KOneLoopValue )
{
loop = KOneLoopValue;
}
else if ( loop > KMaxLoopValue )
{
loop = KMaxLoopValue;
}
}
}
// Retrieve the "volume" attribute value, default is max, so that if the
// "volume" attribute isn't present, the user preferences will not get
// overwritten. There is a check in controller->SetVolumeByAttribute that
// checks current and attribute volume and choses lower volume.
TInt positionVolumeValue( 0 );
TInt CRVolume( KCRVolumeMax );
TPtrC16 volumeValue;
TInt positionVol = argn->Find( KVolume, positionVolumeValue, ECmpFolded );
if ( positionVol == 0 )
{
TPtrC16 pointerVolumeValue( (*argv)[positionVolumeValue] );
volumeValue.Set( pointerVolumeValue );
if ( !(volumeValue.Compare( KHigh )) )
{
CRVolume = KCRVolume10;
}
else if ( !(volumeValue.Compare( KMiddle )) )
{
CRVolume = KCRVolume5;
}
else if ( !(volumeValue.Compare( KLow )) )
{
CRVolume = KCRVolume2;
}
else
{
// Convert volume numeric string (i.e. volume="6") to CR volume
HBufC8* convertPointerVolumeValue = HBufC8::New( pointerVolumeValue.Length() );
TPtr8 convertToByteVolume = convertPointerVolumeValue->Des();
convertToByteVolume.Append( pointerVolumeValue );
CRVolume = atoi( (char*)(convertToByteVolume.Ptr()) );
if ( CRVolume < KCRVolumeMute )
{
CRVolume = KCRVolumeMute;
}
else if ( CRVolume > KCRVolumeMax )
{
CRVolume = KCRVolumeMax;
}
}
}
// Set the Volume and Loop for plugin
pluginInstance->SetVolumeAndLoop( CRVolume, loop, infiniteFlag );
// Retrieve the "src" or "data" attribute value, if it is rtsp scheme lets
// save it, so we can start a controller, since rtsp content is not passed
// by WebKit. It is our (Bavp) responsibilty to load rtsp content.
TInt srcIndex( 0 );
TInt ret = argn->Find( KSrc, srcIndex, ECmpFolded );
if ( ret != 0 )
{
// If the src attribute NOT found, try to find data attribute
ret = argn->Find( KData, srcIndex, ECmpFolded );
}
if ( ret == 0 )
{
// We found either data or src attribute
TPtrC16 srcValue( (*argv)[ srcIndex ] );
TUriParser uriParser;
uriParser.Parse( srcValue );
if ( !uriParser.Extract( EUriScheme ).Compare( KRtsp ) )
{
// We found a RTSP scheme. Lets save it up, so when the BavpView
// is create we can start the BavpController and load rtsp. This
// is because rtsp will not be started by a call to BavpAsFile().
// NOTE: Files (http) are downloaded first and then BavpAsFile()
// is called, which starts the BavpController.
pluginInstance->SetRtspUriL( uriParser.UriDes() );
// We may have to move this to a different place if eg: the url of
// the object is changed later (say from javascript)
CBavpPluginEcomMain* lBavpPluginEcomMain = (CBavpPluginEcomMain*) Dll::Tls();
NPNetscapeFuncs* funcPtr = lBavpPluginEcomMain->Funcs();
if ( funcPtr && funcPtr->getvalue )
{
funcPtr->getvalue( aInstance, NPNNetworkAccess, (void *)&accessPtId);
pluginInstance->SetAccessPtId( accessPtId );
}
}
}
}
// -----------------------------------------------------------------------------
// BavpDestroy(NPP aInstance, NPSavedData**)
// Called by Browser to destroy the plugin
// Returns: NPError: Error Code
// -----------------------------------------------------------------------------
NPError BavpDestroy( NPP aInstance, // Link to Browser
NPSavedData** /*save*/ ) // Not used locally
{
Log( EFalse, _L("Calling FUNCTION BavpDestroy") );
CBavpPlugin *pluginInstance = STATIC_CAST( CBavpPlugin*, aInstance->pdata );
delete pluginInstance;
return NPERR_NO_ERROR;
}
// -----------------------------------------------------------------------------
// BavpSetwindow
// This is the parent window of plugin
// Returns: NPError: Error Code
// -----------------------------------------------------------------------------
NPError BavpSetwindow( NPP aInstance, // Link to Browser
NPWindow* aWindow ) // Browser's window passed to Bavp
{
Log( EFalse, _L("Calling FUNCTION BavpSetwindow") );
CBavpPlugin *pluginInstance = STATIC_CAST( CBavpPlugin*, aInstance->pdata );
MPluginAdapter *pluginAdapter = STATIC_CAST( MPluginAdapter*, aWindow->window);
TRAPD( err, pluginInstance->SetWindowL(pluginAdapter, aWindow, aInstance) );
if ( err == KErrNoMemory )
{
Log( EFalse, _L("FUNCTION BavpSetWindow ERROR! Out of Memory Error") );
// Set the error to plugin if err occurs, it's for the next create plugin check
pluginInstance->iError = ETrue;
return NPERR_OUT_OF_MEMORY_ERROR;
}
if ( err != KErrNone )
{
Log( EFalse, _L("FUNCTION BavpSetWindow ERROR: %d"), err );
// Set the error to plugin if err occurs, it's for the next create plugin check
pluginInstance->iError = ETrue;
return NPERR_GENERIC_ERROR;
}
return NPERR_NO_ERROR;
}
// -----------------------------------------------------------------------------
// BavpNewstream
// Indicates start of downloading of an video file from the internet
// Returns: NPError: Error Code
// -----------------------------------------------------------------------------
NPError BavpNewstream( NPP instance,
NPMIMEType type,
NPStream* /*stream*/, //
NPBool /*seekable*/, //
uint16* stype ) // Will set to NP_ASFILEONLY to notify Browser how to send data
{
Log( EFalse, _L("Calling FUNCTION BavpNewstream") );
// Bavp needs to set stype to alert Browser to send data via Bavp_asfile
*stype = NP_ASFILEONLY;
CBavpPlugin *pluginInstance = STATIC_CAST( CBavpPlugin*, instance->pdata );
pluginInstance->SetMimeType( type );
return NPERR_NO_ERROR;
}
// -----------------------------------------------------------------------------
// BavpDestroystream NOT USED
// Indicates completion of downloading an video file from the internet
// Returns: NPError: Error Code
// -----------------------------------------------------------------------------
NPError BavpDestroystream( NPP /*instance*/, // Not used locally
NPStream* /*stream*/, //
NPReason /*aReason*/ ) //
{
Log( EFalse, _L("Calling FUNCTION BavpDestroyStream") );
return NPERR_NO_ERROR;
}
// -----------------------------------------------------------------------------
// BavpAsfile
// Called by Browser when data is copied to a file.
// Returns: void
// -----------------------------------------------------------------------------
void BavpAsfile( NPP aInstance, // Link to Browser
NPStream* stream,
const TDesC& aFileName ) // file name and path
{
Log( EFalse, _L("Calling FUNCTION BavpAsfile") );
Log( EFalse, _L("Filename:") );
Log( EFalse, aFileName );
CBavpPlugin *pluginInstance = STATIC_CAST( CBavpPlugin*, aInstance->pdata );
// Get the error, and set this error to iError in plugin
TRAPD( err, pluginInstance->OpenAndPlayFileL( aFileName, stream->url ) );
if ( err != KErrNone )
{
Log( EFalse, _L("FUNCTION BavpAsfile ERROR!") );
// If error, set for plugin, it's for the next create plugin check
pluginInstance->iError = ETrue;
}
}
// -----------------------------------------------------------------------------
// BavpWriteready NOT SUPPORTED
// -----------------------------------------------------------------------------
int32 BavpWriteready( NPP /*instance*/,
NPStream* /*stream*/ )
{
// Not implemented
return NPERR_NO_ERROR;
}
// -----------------------------------------------------------------------------
// BavpWrite NOT SUPPORTED
// -----------------------------------------------------------------------------
int32 BavpWrite( NPP /*instance*/,
NPStream* /*stream*/,
int32 /*offset*/,
int32 /*len*/,
void* /*buffer*/ )
{
// Not implemented
return NPERR_NO_ERROR;
}
// -----------------------------------------------------------------------------
// BavpPrint NOT SUPPORTED
// -----------------------------------------------------------------------------
void BavpPrint( NPP /*instance*/,
NPPrint* /*platformPrint*/ )
{
// Not implemented
}
// -----------------------------------------------------------------------------
// BavpEvent NOT SUPPORTED
// -----------------------------------------------------------------------------
int16 BavpEvent( NPP instance,
void* event )
{
TInt ret = EFalse;
if (instance)
{
CBavpPlugin *plugin = static_cast<CBavpPlugin*>(instance->pdata);
NPEvent *ev = static_cast<NPEvent*>(event);
if (plugin)
{
if (ev->event == ENppEventPointer)
{
NPEventPointer *evp =static_cast<NPEventPointer*> (ev->param);
ret = plugin->HandleGesture(evp->reserved);
}
}
}
return ret;
}
// -----------------------------------------------------------------------------
// BavpUrlnotify NOT SUPPORTED
// -----------------------------------------------------------------------------
void BavpUrlnotify( NPP /*instance*/,
const TDesC8& /*url*/,
NPReason /*reason*/,
void* /*notifyData*/ )
{
// Not implemented
}
// -----------------------------------------------------------------------------
// BavpSetvalue NOT SUPPORTED
// -----------------------------------------------------------------------------
NPError BavpSetvalue( NPP /*instance*/,
NPNVariable /*variable*/,
void* /*ret_value*/ )
{
// Not implemented
return NPERR_NO_ERROR;
}
// -----------------------------------------------------------------------------
// BavpGetvalue NOT SUPPORTED
// -----------------------------------------------------------------------------
NPError BavpGetvalue( NPP aInstance,
NPPVariable aVariable,
void* ret_value )
{
NPError err( NPERR_NO_ERROR );
switch( aVariable )
{
case NPPVpluginInteractiveBool:
// Interactive=0, Not Interactive=1
*(TBool *)ret_value = EFalse;
break;
case NPPVpluginScriptableNPObject:
{
// return instance of scripting object to the browser
BavpNPObject *pluginNPObject = BavpNPObject_new( aInstance );
CBavpPlugin *bavpplugin = (CBavpPlugin*)aInstance->pdata;
bavpplugin->SetNPObject(pluginNPObject);
pluginNPObject->plugin = bavpplugin;
pluginNPObject->nppInstance = aInstance;
void** ret = (void**)ret_value;
*ret = (void*)pluginNPObject;
}
break;
default:
break;
} //end switch
return err;
}
// End of File