// -----------------------------------------------------------------------------
// ActivateZoom
// -----------------------------------------------------------------------------
EXPORT_C void CGlxHdmiController::ActivateZoom(TBool aAutoZoomOut)
{
TRACER("CGlxHdmiController::ActivateZoom()");
if (iSurfaceUpdater)
{
iSurfaceUpdater->ActivateZoom(aAutoZoomOut);
}
}
// -----------------------------------------------------------------------------
// NewL
// -----------------------------------------------------------------------------
//
CGlxFetchErrorArray* CGlxFetchErrorArray::NewL(const CGlxFetchErrorArray* aErrorArray)
{
TRACER("CGlxFetchErrorArray::NewL");
CGlxFetchErrorArray* self = CGlxFetchErrorArray::NewLC(aErrorArray);
CleanupStack::Pop(self);
return self;
}
// -----------------------------------------------------------------------------
// NewLC
// -----------------------------------------------------------------------------
EXPORT_C CGlxHdmiController* CGlxHdmiController::NewL(TRect aRect)
{
TRACER("CGlxHdmiController* CGlxHdmiController::NewL()");
CGlxHdmiController* self = new (ELeave) CGlxHdmiController(aRect);
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop(self);
return self;
}
// -----------------------------------------------------------------------------
// ConstructL
// -----------------------------------------------------------------------------
//
void CGlxGarbageCollector::ConstructL()
{
TRACER("CGlxGarbageCollector::ConstructL");
// Create callback loop in the lowest priority, so that the garbage
// collection does not slow down the application
iPeriodic = CPeriodic::NewL( CActive::EPriorityIdle );
iAttributesInUse.ReserveL(KMaxAttributesInUse);
}
// -----------------------------------------------------------------------------
// Clean up cache that is currently under cleanup
// return number of items yet to scan during this idle callback
// -----------------------------------------------------------------------------
//
TInt CGlxGarbageCollector::CleanupCache( CGlxCache& aCache,
TInt aRemainingScanCount )
{
TRACER( "CGlxGarbageCollector::CleanupCache" );
// set the maximum number of items to scan during this call
TInt remainingScanCount = aRemainingScanCount;
// don't store cache.Count() locally, as the count changes during the loop
while ( iScanningPosition.iNextMediaIndexToCleanup < aCache.Count() &&
remainingScanCount > 0 && ( aCache.IdSpaceId() != KGlxIdSpaceIdRoot ) )
{
CGlxMedia& media = aCache.Media( iScanningPosition.iNextMediaIndexToCleanup );
if ( media.UserCount() > 0 )
{
// the media object still has users. Check if any attributes
// it has can be deleted.
TRAPD( err, CleanupMediaL( aCache, media ) );
// skip the media object if cleanup failed. This allows cleanup to
// continue also when has no free memory. Skip also if there
// are still attributes in use.
if ( ( media.Count() == 0 && !err ) || ( err > 0 ) )
{
// the media object has no more attributes. It can be deleted.
// don't increment iNextMediaIndexToCleanup since the index
// of the next item will be decreased by one due to removal
aCache.Delete( iScanningPosition.iNextMediaIndexToCleanup );
GLX_LOG_INFO1( "CGlxGarbageCollector - Deleted Media Id=%d since no attributes left", media.Id().Value());
}
else if( err < 0 )
{
// scan next item
iScanningPosition.iNextMediaIndexToCleanup++;
}
else
{
// scan next item
iScanningPosition.iNextMediaIndexToCleanup++;
}
}
else
{
// the media object has no more users in present cache. It may be deleted
if( !MediaInUse( media ) )
{
// Bug Fix @ EDDG-7V3CJA:: Recheck other caches for UserCount
aCache.Delete( iScanningPosition.iNextMediaIndexToCleanup );
GLX_LOG_INFO1( "CGlxGarbageCollector - Deleted Media Id=%d since no users left", media.Id().Value());
}
}
remainingScanCount--;
}
return remainingScanCount;
}
// -----------------------------------------------------------------------------
// NewLC
// -----------------------------------------------------------------------------
//
CGlxFetchErrorArray* CGlxFetchErrorArray::NewLC(const CGlxFetchErrorArray* aErrorArray)
{
TRACER("CGlxFetchErrorArray::NewLC");
CGlxFetchErrorArray* self = new( ELeave ) CGlxFetchErrorArray();
CleanupStack::PushL( self );
self->CopyConstructL(aErrorArray);
return self;
}
// return true if the atom is t = t
// 29/04/2002 Manchester
bool Atom::isTautology () const
{
TRACER("Atom::isTautology");
if ( ! isEquality() )
return false;
return args().head().equal(args().second());
} // Atom::isTautology
// -----------------------------------------------------------------------------
// ShiftToCloningMode
// -----------------------------------------------------------------------------
EXPORT_C void CGlxHdmiController::ShiftToCloningMode()
{
TRACER("CGlxHdmiController::ShiftToCloningMode()");
// Shift to cloning only if HDMI is connected and surfaceupdater available.
if (iSurfaceUpdater)
{
iSurfaceUpdater->ShiftToCloningMode();
}
}
// -----------------------------------------------------------------------------
// DestroySurfaceUpdater
// -----------------------------------------------------------------------------
void CGlxHdmiController::DestroySurfaceUpdater()
{
TRACER("CGlxHdmiController::DestroySurfaceUpdater()");
if (iSurfaceUpdater)
{
delete iSurfaceUpdater;
iSurfaceUpdater = NULL;
}
}
EXPORT_C void CGlxDataSourceTask::HandleRequestComplete(TInt aError)
{
TRACER("void CGlxDataSourceTask::HandleRequestComplete(TInt aError)");
GLX_DEBUG2("Entering CGlxDataSourceTask::HandleRequestComplete() error %d", aError);
if( !iCancelled && iResponse && iObserver )
{
iObserver->HandleResponse(iResponse, iRequest, aError);
iDataSource->HandleTaskComplete(this);
}
}
// -----------------------------------------------------------------------------
// CancelCleanup
// -----------------------------------------------------------------------------
//
void CGlxGarbageCollector::CancelCleanup()
{
TRACER("CGlxGarbageCollector::CancelCleanup");
if (iPeriodic->IsActive())
{
iPeriodic->Cancel();
// Consideration of Restarting the timer is there;
}
}
CGlxGetRequest::CGlxGetRequest(const RArray<TGlxMediaId>& aMediaIdArray,
const RArray<TMPXAttribute>& aAttributeArray,
const RArray<TMPXAttribute>& aCpiAttributeArray,
const TUid& aCollectionPluginUid,
const TBool aDoNotNeedDataSource)
: CGlxRequest(aCollectionPluginUid, aDoNotNeedDataSource), iMediaIdArray(aMediaIdArray),
iAttributeArray(aAttributeArray), iCpiAttributeArray(aCpiAttributeArray)
{
TRACER("CGlxGetRequest::CGlxGetRequest()");
}
// -----------------------------------------------------------------------------
// DestroyContainer
// -----------------------------------------------------------------------------
void CGlxHdmiController::DestroyContainer()
{
TRACER("CGlxHdmiController::DestroyContainer()");
if (iHdmiContainer)
{
GLX_LOG_INFO("CGlxHdmiController::DestroyHdmi() - deleting iHdmiContainer 1");
delete iHdmiContainer;
iHdmiContainer = NULL;
}
}
// -----------------------------------------------------------------------------
// NewL
// -----------------------------------------------------------------------------
//
CGlxGarbageCollector* CGlxGarbageCollector::NewL(
const RPointerArray<CGlxCache>& aCaches )
{
TRACER( "CGlxGarbageCollector::NewL" );
CGlxGarbageCollector* self = new( ELeave ) CGlxGarbageCollector( aCaches );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop(self);
return self;
}
// -----------------------------------------------------------------------------
// Unmark all medialist items.
// -----------------------------------------------------------------------------
EXPORT_C void MGlxMediaList::UnmarkAllL( MGlxMediaList& aList )
{
TRACER("MGlxMediaList::UnmarkAllL");
TInt count = aList.Count();
for ( TInt i = 0; i <= count ; i++ )
{
aList.SetSelectedL( i, EFalse );
}
}
TBool CGlxDataSourceTask::ObserverMatch(MGlxDataSourceRequestObserver& aObserver)
{
TRACER("TBool CGlxDataSourceTask::ObserverMatch(MGlxDataSourceRequestObserver& aObserver)");
if(&aObserver == iObserver)
{
return ETrue;
}
else
{
return EFalse;
}
}
// true if this is t1 = t2 and a is t2 = t1
// 29/04/2002, Manchester
// 28/08/2002 Torrevieja changed
bool Atom::swap (Atom a) const
{
TRACER("Atom::swap");
if ( ! isEquality() )
return false;
if ( ! a.isEquality() )
return false;
return args().head().equal (a.args().second()) &&
a.args().head().equal(args().second());
} // Atom::swap
// 28/08/2002 Torrevieja
void Atom::rectify (Substitution& subst, Var& last, VarList& freeVars)
{
TRACER ("Atom::rectify");
TermList ts (args());
ts.rectify (subst, last, freeVars);
if (ts == args()) { // space-economic version
return;
}
Atom a (functor(),ts);
*this = a;
} // Atom::rectify
// -----------------------------------------------------------------------------
// CopyConstructL
// -----------------------------------------------------------------------------
//
void CGlxFetchErrorArray::CopyConstructL(const CGlxFetchErrorArray* aErrorArray)
{
TRACER("CGlxFetchErrorArray::CopyConstructL");
if ( aErrorArray )
{
TInt count = aErrorArray->iFetchErrors.Count();
for ( TInt index = 0; index < count; index++ )
{
iFetchErrors.AppendL(aErrorArray->iFetchErrors[index]);
}
}
}
// 28/08/2002 Torrevieja
void Atom::apply ( const Substitution& subst )
{
TRACER ("Atom::apply");
TermList ts (args());
ts.apply (subst);
if (ts == args()) { // space-economic version
return;
}
Atom a (functor(),ts);
*this = a;
} // Atom::apply
// -----------------------------------------------------------------------------
// destructor
// -----------------------------------------------------------------------------
EXPORT_C CGlxHdmiController::~CGlxHdmiController()
{
TRACER("CGlxHdmiController::~CGlxHdmiController()");
DestroySurfaceUpdater();
DestroyContainer();
delete iStoredImagePath;
iStoredImagePath = NULL;
if (iFsBitmap)
{
delete iFsBitmap;
iFsBitmap = NULL;
}
}
// -----------------------------------------------------------------------------
// Callback from periodic timer
// -----------------------------------------------------------------------------
//
TInt CGlxGarbageCollector::PeriodicCallbackL( TAny* aPtr )
{
TRACER("CGlxGarbageCollector::PeriodicCallback");
GLX_ASSERT_DEBUG( aPtr != NULL, Panic( EGlxPanicLogicError ),
"Received null pointer for garbage collector" );
// get "this" pointer
static_cast< CGlxGarbageCollector* >( aPtr )->PeriodicCallbackL();
// return value ignored for periodic timers
return 0;
}
/**
* Init_hermann_rdkafka
*
* Called by Ruby when the Hermann gem is loaded.
* Defines the Hermann module.
* Defines the Producer and Consumer classes.
*/
void Init_hermann_rdkafka() {
VALUE lib_module, provider_module, c_consumer, c_producer;
TRACER("setting up Hermann::Provider::RDKafka\n");
/* Define the module */
hermann_module = rb_define_module("Hermann");
provider_module = rb_define_module_under(hermann_module, "Provider");
lib_module = rb_define_module_under(provider_module, "RDKafka");
/* ---- Define the consumer class ---- */
c_consumer = rb_define_class_under(lib_module, "Consumer", rb_cObject);
/* Allocate */
rb_define_alloc_func(c_consumer, consumer_allocate);
/* Initialize */
rb_define_method(c_consumer, "initialize", consumer_initialize, 4);
rb_define_method(c_consumer, "initialize_copy", consumer_init_copy, 1);
/* Consumer has method 'consume' */
rb_define_method( c_consumer, "consume", consumer_consume, 1);
/* ---- Define the producer class ---- */
c_producer = rb_define_class_under(lib_module, "Producer", rb_cObject);
/* Allocate */
rb_define_alloc_func(c_producer, producer_allocate);
/* Initialize */
rb_define_method(c_producer, "initialize", producer_initialize, 1);
rb_define_method(c_producer, "initialize_copy", producer_init_copy, 1);
/* Producer.push_single(msg) */
rb_define_method(c_producer, "push_single", producer_push_single, 3);
/* Producer.tick */
rb_define_method(c_producer, "tick", producer_tick, 1);
/* Producer.connected? */
rb_define_method(c_producer, "connected?", producer_is_connected, 0);
/* Producer.errored? */
rb_define_method(c_producer, "errored?", producer_is_errored, 0);
/* Producer.connect */
rb_define_method(c_producer, "connect", producer_connect, 1);
/* Producer.metadata */
rb_define_method(c_producer, "metadata", producer_metadata, 2);
}
void CGlxRequest::ConstructL(const CMPXFilter* aFilter)
{
TRACER("void CGlxRequest::ConstructL(const CMPXFilter* aFilter)");
if (aFilter)
{
// Take a copy of the filter as we do not own it.
iFilter = CMPXFilter::NewL(*aFilter);
}
else
{
// No filter supplied, so create a default filter;
iFilter = TGlxFilterFactory::CreateAlphabeticSortFilterL();
}
}
// -----------------------------------------------------------------------------
// GetAttributesInUseL
// -----------------------------------------------------------------------------
//
void CGlxGarbageCollector::GetAttributesInUseL( const CGlxMedia& aMedia,
RArray<TMPXAttribute>& aAttributes ) const
{
TRACER("CGlxGarbageCollector::GetAttributesInUseL");
// get needed attributes from each user of the media object
// ( unlikely to have many users, so calling CGlxMedia::UserCount and
// CGlxMedia::Id within the loop )
for ( TInt userIndex = 0; userIndex < aMedia.UserCount(); userIndex++ )
{
aMedia.User( userIndex ).GetRequiredAttributesL( aMedia.IndexInUser( userIndex ),
aAttributes );
}
}
static VALUE producer_connect(VALUE self, VALUE timeout) {
HermannInstanceConfig *producerConfig;
rd_kafka_resp_err_t err;
VALUE result = Qfalse;
hermann_metadata_ctx_t md_context;
Data_Get_Struct(self, HermannInstanceConfig, producerConfig);
if (!producerConfig->isInitialized) {
producer_init_kafka(self, producerConfig);
}
md_context.rk = producerConfig->rk;
md_context.topic = NULL;
md_context.data = NULL;
md_context.timeout_ms = rb_num2int(timeout);
err = producer_metadata_request(&md_context);
TRACER("err: %s (%i)\n", rd_kafka_err2str(err), err);
if (RD_KAFKA_RESP_ERR_NO_ERROR == err) {
TRACER("brokers: %i, topics: %i\n",
md_context.data->broker_cnt,
md_context.data->topic_cnt);
producerConfig->isConnected = 1;
result = Qtrue;
}
else {
producerConfig->isErrored = err;
}
if ( md_context.data )
rd_kafka_metadata_destroy(md_context.data);
return result;
}
EXPORT_C CGlxGetRequest* CGlxGetRequest::NewL(const RArray<TGlxMediaId>& aMediaIdArray,
const RArray<TMPXAttribute>& aAttributeArray,
const RArray<TMPXAttribute>& aCpiAttributeArray,
const TUid& aCollectionPluginUid,
CMPXFilter* aFilter,
const TBool aDoNotNeedDataSource)
{
TRACER("CGlxGetRequest* CGlxGetRequest::NewL()");
CGlxGetRequest* task = new (ELeave) CGlxGetRequest(aMediaIdArray, aAttributeArray,
aCpiAttributeArray, aCollectionPluginUid, aDoNotNeedDataSource);
CleanupStack::PushL(task);
task->ConstructL(aFilter);
CleanupStack::Pop(task);
return task;
}
// return true if the atoms are r = s, s = t, and r = t (up to commutativity)
// 29/04/2002 Manchester
// 28/08/2002 Torrevieja, changed
bool Atom::transitivity (Atom a1, Atom a2, Atom a3)
{
TRACER("Atom::transitivity");
if ( ! (a1.isEquality() &&
a2.isEquality() &&
a3.isEquality()) ) {
return false;
}
// a1, a2, a3 are equalities
Term l1 (a1.args().head());
Term r1 (a1.args().second());
if ( l1.equal(r1) ) {
return false;
}
Term l2 (a2.args().head());
Term r2 (a2.args().second());
if ( l2.equal(r2) ) {
return false;
}
Term l3 (a3.args().head());
Term r3 (a3.args().second());
if ( l3.equal(r3) ) {
return false;
}
if ( l1.equal(l2) ) { // l1 = l2 = s
return (r1.equal(l3) && r2.equal(r3)) ||
(r2.equal(l3) && r1.equal(r3));
}
// l1 != l2
if ( l1.equal(r2) ) { // l1 = r2 = s
return (r1.equal(l3) && l2.equal(r3)) ||
(l2.equal(l3) && r1.equal(r3));
}
//
if ( r1.equal(l2) ) { // r1 = l2 = s
return (l1.equal(l3) && r2.equal(r3)) ||
(r2.equal(l3) && l1.equal(r3));
}
// l1 not in {l2,r2}, r1 != l2
if ( r1.equal(r2) ) { // r1 = r2 = s
return (l1.equal(l3) && l2.equal(r3)) ||
(l2.equal(l3) && l1.equal(r3));
}
return false;
} // Atom::transitivity
// -----------------------------------------------------------------------------
// Flush Count Pages
// -----------------------------------------------------------------------------
//
void CGlxGarbageCollector::FlushPagesL(TInt aCount)
{
TRACER("CGlxGarbageCollector::FlushPagesL");
TBool reachedEnd = CleanupCaches(aCount);
if ( reachedEnd )
{
// reset to the start of the caches
iScanningPosition.iCurrentCacheIndex = 0;
iScanningPosition.iNextMediaIndexToCleanup = 0;
// next time the full round reaches end, the caches will be fully clean
// (unless client calls Cleanup() )
iRequiresFullCleanupRound = EFalse;
}
}
// -----------------------------------------------------------------------------
// Delete all attributes from a media object except those specified
// -----------------------------------------------------------------------------
//
void CGlxGarbageCollector::DeleteOtherAttributes( CGlxCache& /*aCache*/, CGlxMedia& aMedia,
const RArray<TMPXAttribute>& aAttributesToKeep ) const
{
TRACER("CGlxGarbageCollector::DeleteOtherAttributes");
// loop backwards so can delete attributes during the loop
for ( TInt attrIndex = aMedia.Count() - 1; attrIndex >= 0; attrIndex-- )
{
// delete the attribute if it is not in use
if ( KErrNotFound == aAttributesToKeep.Find( aMedia.Attribute( attrIndex ), TMPXAttribute::Match ) )
{
GLX_LOG_INFO( "CGlxGarbageCollector::CleanupMediaL - Deleted attribute" );
aMedia.DeleteAttribute( attrIndex );
}
}
}
