/**********************************
* Method: ConstructL
**********************************/
void CEmailStorePreInstall::ConstructL()
{
__LOG_ENTER("ConstructL")
// Construct base
CTimer::ConstructL();
// Define upgrade property.
// Define security rights
TSecurityPolicy readPolicy( ECapabilityReadDeviceData );
TSecurityPolicy writePolicy( ECapabilityWriteDeviceData );
TInt err = RProperty::Define( KEmailStoreUpgradePSCategory,
KProperty_EmailStore_Upgrade,
RProperty::EInt,
readPolicy,
writePolicy );
if ( KErrNone != err && KErrAlreadyExists != err )
{
User::Leave( err );
}
// We are an AO
CActiveScheduler::Add(this);
// Need timeout for closing a process
iTimeoutTimer = CProcessTimer::NewL(*this);
// Start right away
CTimer::After( 0 );
__LOG_EXIT
}
/** Initialise the resources needed for the channel.
This must be called before a client can connect to the channel
by calling RLbsNetRequestChannel::OpenL().
This may do tasks such as creating the RMsgQueue used internally (or
RProperties if publish and subscribe is being used).
*/
EXPORT_C void RLbsTestChannel::InitializeL(TLbsTestChannelId aChannelId)
{
TSecurityPolicy readPolicy(ECapabilityLocation);
TSecurityPolicy writePolicy(ECapabilityWriteDeviceData);
TInt err = RProperty::Define(TUid::Uid(KPropTable[aChannelId][KCategoryKeyIndex]),
KPropTable[aChannelId][KWritePropKeyIndex],
RProperty::ELargeByteArray,
KSecurityPolicy, KSecurityPolicy,
KMaximumMessageSizeBytes);
if (err != KErrNone && err != KErrAlreadyExists)
{
User::Leave(err);
}
err = RProperty::Define(TUid::Uid(KPropTable[aChannelId][KCategoryKeyIndex]),
KPropTable[aChannelId][KWritePropAckKeyIndex],
RProperty::EInt,
KSecurityPolicy, KSecurityPolicy);
if (err != KErrNone && err != KErrAlreadyExists)
{
User::Leave(err);
}
User::LeaveIfError(RProperty::Set(TUid::Uid(KPropTable[aChannelId][KCategoryKeyIndex]), KPropTable[aChannelId][KWritePropAckKeyIndex], 0));
}
/** Initialise this interface.
This must be called before any call to OpenL(), to ensure that the
RProperties it uses are correctly initialised.
*/
EXPORT_C void RLbsNetworkPositionUpdates::InitializeL()
{
// There is an assumption that TPositionSatelliteInfo is the biggest
// class to be sent over this interface, so double-check
__ASSERT_COMPILE(sizeof(TPositionSatelliteInfo) >= sizeof(TPositionInfo));
__ASSERT_COMPILE(sizeof(TPositionSatelliteInfo) >= sizeof(TPositionCourseInfo));
TSecurityPolicy readPolicy(ECapabilityLocation);
TSecurityPolicy writePolicy(ECapabilityWriteDeviceData);
// Network reference position property
TInt err = RProperty::Define(KNetworkReferencePositionUpdateKey,
RProperty::ELargeByteArray,
readPolicy,
writePolicy,
sizeof(TLbsPositionUpdateData));
if (err != KErrNone && err != KErrAlreadyExists)
{
User::Leave(err);
}
// Network final position property
err = RProperty::Define(KNetworkFinalPositionUpdateKey,
RProperty::ELargeByteArray,
readPolicy,
writePolicy,
sizeof(TLbsPositionUpdateData));
if (err != KErrNone && err != KErrAlreadyExists)
{
User::Leave(err);
}
// Set default values for the properties
TLbsPositionUpdateData defaultData;
defaultData.iError = KErrNotFound;
defaultData.iTargetTime = 0;
defaultData.iActualTime = 0;
// indicate that the property is ok, but contains no data.
defaultData.iValidData = EFalse;
TLbsPositionUpdateDataPckgC pckg(defaultData);
User::LeaveIfError(RProperty::Set(RProcess().SecureId(),
KNetworkReferencePositionUpdateKey,
pckg));
User::LeaveIfError(RProperty::Set(RProcess().SecureId(),
KNetworkFinalPositionUpdateKey,
pckg));
// Save the Uid of the process which called InitializeL()
// in the cenrep file owned by LbsRoot.
SetCategoryUidL(KNetworkPositionUpdateCategoryKey,
RProcess().SecureId());
}
void CreateDatabaseL(const TDesC& aDbName)
{
// create the database now
RSqlSecurityPolicy securityPolicy;
CleanupClosePushL(securityPolicy);
TSecurityPolicy policy(TSecurityPolicy::EAlwaysPass);
securityPolicy.Create(policy);
TSecurityPolicy schemaPolicy(TSecurityPolicy::EAlwaysPass);
TSecurityPolicy readPolicy(TSecurityPolicy::EAlwaysPass);
TSecurityPolicy writePolicy(TSecurityPolicy::EAlwaysPass);
User::LeaveIfError(securityPolicy.SetDbPolicy(RSqlSecurityPolicy::ESchemaPolicy, schemaPolicy));
User::LeaveIfError(securityPolicy.SetDbPolicy(RSqlSecurityPolicy::EReadPolicy, readPolicy));
User::LeaveIfError(securityPolicy.SetDbPolicy(RSqlSecurityPolicy::EWritePolicy, writePolicy));
TheTest.Printf(_L("Creating Database %S\n"), &aDbName);
TInt err = TheDbC.Create(aDbName, securityPolicy, &TheSqlConfigString);
if (KErrAlreadyExists == err)
{
// the file already exists
// make sure we delete the file
User::LeaveIfError(TheDbC.Delete(aDbName));
// try again
err = TheDbC.Create(aDbName, securityPolicy, &TheSqlConfigString);
}
User::LeaveIfError(err);
//Create tables
User::LeaveIfError(TheDbC.Exec(KMusicCreateTable));
User::LeaveIfError(TheDbC.Exec(KAuxiliaryCreateTable));
User::LeaveIfError(TheDbC.Exec(KAlbumCreateTable));
User::LeaveIfError(TheDbC.Exec(KArtistCreateTable));
User::LeaveIfError(TheDbC.Exec(KComposerCreateTable));
User::LeaveIfError(TheDbC.Exec(KGenreCreateTable));
User::LeaveIfError(TheDbC.Exec(KPlaylistCreateTable));
User::LeaveIfError(TheDbC.Exec(KPlaylistSongInfoCreateTable));
User::LeaveIfError(TheDbC.Exec(KPlaylistSongsCreateTable));
TheDbC.Close();
CleanupStack::PopAndDestroy(&securityPolicy);
}
// -----------------------------------------------------------------------------
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CSatSystemState::ConstructL( MSatMultiModeApi& aPhone )
{
LOG( SIMPLE, "SATSYSTEMSTATE: CSatSystemState::ConstructL calling" )
// Define policies
TSecurityPolicy readPolicy( ECapabilityReadUserData );
TSecurityPolicy writePolicy( ECapabilityWriteUserData );
DefineProperty( KPSUidSatServerInternal,
KSatIdleModeText,
RProperty::ELargeText,
readPolicy,
writePolicy );
DefineProperty( KPSUidSatServerInternal,
KSatIdleModeTextIconId,
RProperty::EInt,
readPolicy,
writePolicy );
DefineProperty( KPSUidSatServerInternal,
KSatIdleModeTextIconQualifier,
RProperty::EInt,
readPolicy,
writePolicy );
// Set default (empty) values
WriteSetIdleModeText( KNullDesC, KErrNotFound, RSat::ENoIconId );
DefineProperty( KPSUidSatServer,
KSatLanguageSelectionTimeBeforeReboot,
RProperty::EInt,
readPolicy,
writePolicy );
// Create Network Registration Status Monitor.
iNetworkRegStatusMonitor = CSatNetworkRegStatusMonitor::NewL( aPhone );
// Start Network Registration Status Monitor.
iNetworkRegStatusMonitor->Start();
LOG( SIMPLE, "SATSYSTEMSTATE: CSatSystemState::ConstructL exiting" )
}
EXPORT_C void RLbsNetworkLocationResponses::InitializeL()
{
TSecurityPolicy readPolicy(ECapabilityLocation);
TSecurityPolicy writePolicy(ECapabilityWriteDeviceData);
TInt err = RProperty::Define(KNetworkLocationResponseMessageKey,
RProperty::EByteArray,
readPolicy,
writePolicy,
KMaxLbsNetLocMsgSize);
if (err != KErrNone && err != KErrAlreadyExists)
{
User::Leave(err);
}
// Save the Uid of the process which called InitializeL()
// in the cenrep file owned by LbsRoot.
LbsNgNlmIntCommon::SetCategoryUidL(KNetworkLocationResponseCategoryKey,
RProcess().SecureId());
}
// ----------------------------------------------------------------------------
// CNWNetworkViagBaseEngine::ConstructL
// Symbian 2nd phase constructor can leave.
// ----------------------------------------------------------------------------
//
void CNWNetworkViagBaseEngine::ConstructL()
{
NWLOGSTRING( KNWOBJECT,
"NW: CNWNetworkViagBaseEngine::ConstructL() Begin." );
RProperty::TType type( RProperty::EInt );
TSecurityPolicy readPolicy( ECapability_None );
TSecurityPolicy writePolicy( ECapabilityWriteDeviceData );
TInt err = RProperty::Define( KPSUidNetworkInfo,
KNWHomeZoneStatus,
type,
readPolicy,
writePolicy );
//An error of KErrAlready exists should be ignored, as this only
//indicates that some other code int system is also interested in the
//value and has created the property.
if ( err != KErrNone && err != KErrAlreadyExists )
{
NWLOGSTRING2( KNWERROR, "NW: CNWNetworkViagBaseEngine::ConstructL \
RProperty::Define error: %d .", err );
User::Leave( err );
}
bool STOMP::runSingleIteration(const int iteration_number)
{
ROS_ASSERT(initialized_);
policy_iteration_counter_++;
if (write_to_file_)
{
// load new policy if neccessary
ROS_VERIFY(readPolicy(iteration_number));
}
ROS_ASSERT(doRollouts(iteration_number));
ROS_ASSERT(doUpdate(iteration_number));
ROS_ASSERT(doNoiselessRollout(iteration_number));
if (write_to_file_)
{
// store updated policy to disc
//ROS_VERIFY(writePolicy(iteration_number));
//ROS_VERIFY(writePolicyImprovementStatistics(stats_msg));
}
return true;
}
bool PolicyImprovementLoop::runSingleIteration(const int iteration_number)
{
ROS_INFO("en iteracio %i", iteration_number);
ROS_ASSERT(initialized_);
policy_iteration_counter_++;
if (write_to_file_)
{
// load new policy if neccessary
ROS_VERIFY(readPolicy(iteration_number));
}
policy_improvement_loop::PolicyImprovementStatistics stats_msg;
stats_msg.rollout_costs.resize(num_rollouts_);
// compute appropriate noise values
std::vector<double> noise;
noise.resize(num_dimensions_);
for (int i=0; i<num_dimensions_; ++i)
{
noise[i] = noise_stddev_[i] * pow(noise_decay_[i], iteration_number-1);
}
// get rollouts and execute them
ROS_VERIFY(policy_improvement_.getRollouts(rollouts_, noise));
for (int r=0; r<int(rollouts_.size()); ++r)
{
ROS_VERIFY(task_.execute(rollouts_[r], tmp_rollout_cost_, rollout_terminal_costs_[r], iteration_number));
rollout_costs_.row(r) = tmp_rollout_cost_.transpose();
ROS_INFO("Rollout %d, cost = %lf", r+1, tmp_rollout_cost_.sum() + rollout_terminal_costs_[r]);
if (write_to_file_)
{
// store updated policy to disc
ROS_VERIFY(writePolicy(iteration_number, true, r));
}
}
// TODO: fix this std::vector<>
std::vector<double> all_costs;
ROS_VERIFY(policy_improvement_.setRolloutCosts(rollout_costs_, rollout_terminal_costs_, control_cost_weight_, all_costs));
// fill in rollout costs for publishing:
for (int r=0; r<num_rollouts_; ++r)
{
stats_msg.rollout_costs[r] = all_costs[r];
}
// improve the policy
ROS_VERIFY(policy_improvement_.improvePolicy(parameter_updates_));
ROS_VERIFY(policy_improvement_.getTimeStepWeights(time_step_weights_));
ROS_VERIFY(policy_->updateParameters(parameter_updates_, time_step_weights_));
// get a noise-less rollout to check the cost
ROS_VERIFY(policy_->getParameters(parameters_));
double terminal_cost=0.0;
ROS_VERIFY(task_.execute(parameters_, tmp_rollout_cost_, terminal_cost, iteration_number));
stats_msg.noiseless_cost = tmp_rollout_cost_.sum() + terminal_cost;
ROS_INFO("Noiseless cost = %lf", stats_msg.noiseless_cost);
stats_msg.iteration = iteration_number;
// add the noiseless rollout into policy_improvement:
std::vector<std::vector<Eigen::VectorXd> > extra_rollout;
std::vector<Eigen::VectorXd> extra_rollout_cost;
std::vector<double> extra_rollout_terminal_cost;
extra_rollout.resize(1);
extra_rollout_cost.resize(1);
extra_rollout_terminal_cost.resize(1);
extra_rollout[0] = parameters_;
extra_rollout_cost[0] = tmp_rollout_cost_;
extra_rollout_terminal_cost[0] = terminal_cost;
ROS_VERIFY(policy_improvement_.addExtraRollouts(extra_rollout, extra_rollout_cost, extra_rollout_terminal_cost));
if (write_to_file_)
{
// store updated policy to disc
ROS_VERIFY(writePolicy(iteration_number));
ROS_VERIFY(writePolicyImprovementStatistics(stats_msg));
}
ROS_INFO_STREAM(stats_msg);
stats_publisher_.publish(stats_msg);
return true;
}
