mitk::PropertyPersistence::InfoResultType mitk::PropertyPersistence::GetInfo(const std::string &propertyName,
const MimeTypeNameType &mime,
bool allowMimeWildCard,
bool allowNameRegEx) const
{
SelectFunctionType select = [propertyName, mime](const InfoMap::value_type &x) {
return infoPredicate(x, propertyName, mime);
};
InfoMap selection = SelectInfo(m_InfoMap, select);
if (allowNameRegEx)
{
select = [propertyName, mime](const InfoMap::value_type &x) { return infoPredicateRegEx(x, propertyName, mime); };
InfoMap regExSelection = SelectInfo(m_InfoMap, select);
selection.insert(regExSelection.begin(), regExSelection.end());
}
if (selection.empty() && allowMimeWildCard)
{ // no perfect match => second run through with "any mime type"
select = [propertyName](const InfoMap::value_type &x) {
return infoPredicate(x, propertyName, PropertyPersistenceInfo::ANY_MIMETYPE_NAME());
};
selection = SelectInfo(m_InfoMap, select);
if (allowNameRegEx)
{
select = [propertyName](const InfoMap::value_type &x) {
return infoPredicateRegEx(x, propertyName, PropertyPersistenceInfo::ANY_MIMETYPE_NAME());
};
InfoMap regExSelection = SelectInfo(m_InfoMap, select);
selection.insert(regExSelection.begin(), regExSelection.end());
}
}
InfoResultType result;
for (const auto &pos : selection)
{
result.push_back(pos.second->UnRegExByName(propertyName).GetPointer());
}
return result;
}
inline static QString toString(const InfoMap &infoMap, const QString sep="\n")
{
QString str("");
InfoMap::const_iterator it = infoMap.begin();
for (; it != infoMap.end() ; ++it)
str += QString("[%1]:%2%3").arg(it.key()).arg(*it).arg(sep);
return str;
}
bool
MediaAddonServer::QuitRequested()
{
CALLED();
InfoMap::iterator iterator = fInfoMap.begin();
for (iterator = fInfoMap.begin(); iterator != fInfoMap.end(); iterator++)
_DestroyInstantiatedFlavors(iterator->second);
BMediaRoster::CurrentRoster()->Lock();
BMediaRoster::CurrentRoster()->Quit();
for (iterator = fInfoMap.begin(); iterator != fInfoMap.end(); iterator++)
_PutAddonIfPossible(iterator->second);
return true;
}
inline
int UserInfoCache::updateUserInfo(int userId, UserInfo *userInfo)
{
int ret = 1;
//..
// Although we intend to update the information, we first acquire a *read*
// *lock* to locate the item. This allows other threads to read the list while
// we find the item. If we do not locate the item we can simply release the
// *read* *lock* and return an error without causing any other *reading* thread
// to block. (Again, other writers *will* block until this *read* *lock* is
// released.)
//..
d_lock.lockRead();
InfoMap::iterator it = d_infoMap.find(userId);
if (d_infoMap.end() != it) {
//..
// Since 'it != end()', we found the item. Now we need to upgrade to a *write*
// *lock*. If we can't do this atomically, then we need to locate the item
// again. This is because another thread may have changed 'd_infoMap' during
// the time between our *read* and *write* locks.
//..
if (d_lock.upgradeToWriteLock()) {
it = d_infoMap.find(userId);
}
//..
// This is a little more costly, but since we don't expect many concurrent
// writes, it should not happen often. In the (likely) event that we do
// upgrade to a *write* *lock* atomically, then the second lookup above is not
// performed. In any case, we can now update the information and release the
// lock, since we already have a pointer to the item and we know that the list
// could not have been changed by anyone else.
//..
if (d_infoMap.end() != it) {
it->second = *userInfo;
ret = 0;
}
d_lock.unlock();
}
else {
d_lock.unlock();
}
return ret;
}
void MythGenericTree::SetTextFromMap(const InfoMap &infoMap,
const QString &state)
{
InfoMap::const_iterator map_it = infoMap.begin();
while (map_it != infoMap.end())
{
TextProperties textprop;
textprop.text = (*map_it);
textprop.state = state;
m_strings[map_it.key()] = textprop;
++map_it;
}
}
inline
int UserInfoCache::getUserInfo(int userId, UserInfo *userInfo)
{
int ret = 1;
//..
// Getting the user info does not require any write access. We do, however,
// need read access to 'd_infoMap', which is controlled by 'd_lock'. (Note
// that writers *will* block until this *read* *lock* is released, but
// concurrent reads are allowed.) The user info is copied into the
// caller-owned location 'userInfo'.
//..
d_lock.lockRead();
InfoMap::iterator it = d_infoMap.find(userId);
if (d_infoMap.end() != it) {
*userInfo = it->second;
ret = 0;
}
d_lock.unlock();
return ret;
}
void
MediaAddonServer::_AddOnRemoved(ino_t fileNode)
{
// TODO: locking?
FileMap::iterator foundFile = fFileMap.find(fileNode);
if (foundFile == fFileMap.end()) {
ERROR("MediaAddonServer::_AddOnRemoved: inode %Ld removed, but no "
"media add-on found\n", fileNode);
return;
}
media_addon_id id = foundFile->second;
fFileMap.erase(foundFile);
int32 oldFlavorCount;
InfoMap::iterator foundInfo = fInfoMap.find(id);
if (foundInfo == fInfoMap.end()) {
ERROR("MediaAddonServer::_AddOnRemoved: couldn't get addon info for "
"add-on %ld\n", id);
oldFlavorCount = 1000;
} else {
AddOnInfo& info = foundInfo->second;
oldFlavorCount = info.flavor_count;
_DestroyInstantiatedFlavors(info);
_PutAddonIfPossible(info);
if (info.addon) {
ERROR("MediaAddonServer::_AddOnRemoved: couldn't unload addon "
"%ld since flavors are in use\n", id);
}
fInfoMap.erase(foundInfo);
}
gDormantNodeManager->UnregisterAddOn(id);
BPrivate::media::notifications::FlavorsChanged(id, 0, oldFlavorCount);
}
void
MediaAddonServer::_ScanAddOnFlavors(BMediaAddOn* addon)
{
ASSERT(addon->AddonID() > 0);
TRACE("MediaAddonServer::_ScanAddOnFlavors: id %ld\n", addon->AddonID());
// cache the media_addon_id in a local variable to avoid
// calling BMediaAddOn::AddonID() too often
media_addon_id addonID = addon->AddonID();
// update the cached flavor count, get oldflavorcount and newflavorcount
InfoMap::iterator found = fInfoMap.find(addonID);
ASSERT(found != fInfoMap.end());
AddOnInfo& info = found->second;
int32 oldFlavorCount = info.flavor_count;
int32 newFlavorCount = addon->CountFlavors();
info.flavor_count = newFlavorCount;
TRACE("%ld old flavors, %ld new flavors\n", oldflavorcount, newFlavorCount);
// during the first update (i == 0), the server removes old dormant_flavor_infos
for (int i = 0; i < newFlavorCount; i++) {
const flavor_info* flavorInfo;
TRACE("flavor %d:\n", i);
if (addon->GetFlavorAt(i, &flavorInfo) != B_OK) {
ERROR("MediaAddonServer::_ScanAddOnFlavors GetFlavorAt failed for "
"index %d!\n", i);
continue;
}
#if DEBUG >= 2
DumpFlavorInfo(flavorInfo);
#endif
dormant_flavor_info dormantFlavorInfo;
dormantFlavorInfo = *flavorInfo;
dormantFlavorInfo.node_info.addon = addonID;
dormantFlavorInfo.node_info.flavor_id = flavorInfo->internal_id;
strlcpy(dormantFlavorInfo.node_info.name, flavorInfo->name,
B_MEDIA_NAME_LENGTH);
size_t flattenedSize = dormantFlavorInfo.FlattenedSize();
size_t messageSize = flattenedSize
+ sizeof(server_register_dormant_node_command);
server_register_dormant_node_command* message
= (server_register_dormant_node_command*)malloc(messageSize);
if (message == NULL)
break;
// The server should remove previously registered "dormant_flavor_info"s
// during the first update, but after the first iteration, we don't
// want the server to anymore remove old dormant_flavor_infos
message->purge_id = i == 0 ? addonID : 0;
message->type = dormantFlavorInfo.TypeCode();
message->flattened_size = flattenedSize;
dormantFlavorInfo.Flatten(message->flattened_data, flattenedSize);
status_t status = SendToServer(SERVER_REGISTER_DORMANT_NODE,
message, messageSize);
if (status != B_OK) {
ERROR("MediaAddonServer::_ScanAddOnFlavors: couldn't register "
"dormant node: %s\n", strerror(status));
}
free(message);
}
// TODO: we currently pretend that all old flavors have been removed, this
// could probably be done in a smarter way
BPrivate::media::notifications::FlavorsChanged(addonID, newFlavorCount,
oldFlavorCount);
}
void
MediaAddonServer::ReadyToRun()
{
if (!be_roster->IsRunning("application/x-vnd.Be.media-server")) {
// the media server is not running, let's quit
fprintf(stderr, "The media_server is not running!\n");
Quit();
return;
}
// the control thread is already running at this point,
// so we can talk to the media server and also receive
// commands for instantiation
ASSERT(fStartup == true);
// The very first thing to do is to create the system time source,
// register it with the server, and make it the default SYSTEM_TIME_SOURCE
BMediaNode *timeSource = new SystemTimeSource;
status_t result = fMediaRoster->RegisterNode(timeSource);
if (result != B_OK) {
fprintf(stderr, "Can't register system time source : %s\n",
strerror(result));
debugger("Can't register system time source");
}
if (timeSource->ID() != NODE_SYSTEM_TIMESOURCE_ID)
debugger("System time source got wrong node ID");
media_node node = timeSource->Node();
result = MediaRosterEx(fMediaRoster)->SetNode(SYSTEM_TIME_SOURCE, &node);
if (result != B_OK)
debugger("Can't setup system time source as default");
// During startup, first all add-ons are loaded, then all
// nodes (flavors) representing physical inputs and outputs
// are instantiated. Next, all add-ons that need autostart
// will be autostarted. Finally, add-ons that don't have
// any active nodes (flavors) will be unloaded.
char parameter[32];
size_t parameterLength = sizeof(parameter);
bool safeMode = false;
if (_kern_get_safemode_option(B_SAFEMODE_SAFE_MODE, parameter,
¶meterLength) == B_OK) {
if (!strcasecmp(parameter, "enabled") || !strcasecmp(parameter, "on")
|| !strcasecmp(parameter, "true") || !strcasecmp(parameter, "yes")
|| !strcasecmp(parameter, "enable") || !strcmp(parameter, "1"))
safeMode = true;
}
fMonitorHandler = new MonitorHandler(this);
AddHandler(fMonitorHandler);
BMessage pulse(B_PULSE);
fPulseRunner = new BMessageRunner(fMonitorHandler, &pulse, 1000000LL);
// the monitor handler needs a pulse to check if add-ons are ready
// load dormant media nodes
const directory_which directories[] = {
B_USER_ADDONS_DIRECTORY,
B_COMMON_ADDONS_DIRECTORY,
B_SYSTEM_ADDONS_DIRECTORY
};
// when safemode, only B_SYSTEM_ADDONS_DIRECTORY is used
for (uint32 i = safeMode ? 2 : 0;
i < sizeof(directories) / sizeof(directory_which); i++) {
BDirectory directory;
node_ref nodeRef;
BPath path;
if (find_directory(directories[i], &path) == B_OK
&& path.Append("media") == B_OK
&& directory.SetTo(path.Path()) == B_OK
&& directory.GetNodeRef(&nodeRef) == B_OK)
fMonitorHandler->AddDirectory(&nodeRef);
}
#ifdef USER_ADDON_PATH
node_ref nodeRef;
if (entry.SetTo(USER_ADDON_PATH) == B_OK
&& entry.GetNodeRef(&nodeRef) == B_OK)
fMonitorHandler->AddDirectory(&nodeRef);
#endif
fStartup = false;
InfoMap::iterator iterator = fInfoMap.begin();
for (; iterator != fInfoMap.end(); iterator++)
_InstantiatePhysicalInputsAndOutputs(iterator->second);
for (iterator = fInfoMap.begin(); iterator != fInfoMap.end(); iterator++)
_InstantiateAutostartFlavors(iterator->second);
for (iterator = fInfoMap.begin(); iterator != fInfoMap.end(); iterator++)
_PutAddonIfPossible(iterator->second);
server_rescan_defaults_command cmd;
SendToServer(SERVER_RESCAN_DEFAULTS, &cmd, sizeof(cmd));
}
