haiku.git

/*
 * Copyright 2002-2024, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Tyler Dauwalder
 *		Ingo Weinhold, bonefish@users.sf.net
 *		Axel Dörfler, axeld@pinc-software.de
 */


#include <mime/SupportingApps.h>

#include <stdio.h>

#include <new>

#include <Directory.h>
#include <Message.h>
#include <MimeType.h>
#include <Path.h>
#include <String.h>

#include <mime/database_support.h>
#include <mime/DatabaseDirectory.h>
#include <mime/DatabaseLocation.h>
#include <storage_support.h>


#define DBG(x) x
//#define DBG(x)
#define OUT printf

namespace BPrivate {
namespace Storage {
namespace Mime {


/*!
	\class SupportingApps
	\brief Supporting apps information for the entire MIME database
*/


SupportingApps::SupportingApps(DatabaseLocation* databaseLocation)
	:
	fDatabaseLocation(databaseLocation),
	fHaveDoneFullBuild(false)
{
}


SupportingApps::~SupportingApps()
{
}


/*! \brief Returns a list of signatures of supporting applications for the
	given type in the pre-allocated \c BMessage pointed to by \c apps.

	See \c BMimeType::GetSupportingApps() for more information.
*/
status_t
SupportingApps::GetSupportingApps(const char *type, BMessage *apps)
{
	if (type == NULL || apps == NULL)
		return B_BAD_VALUE;

	// See if we need to do our initial build still
	if (!fHaveDoneFullBuild) {
		status_t status = BuildSupportingAppsTable();
		if (status != B_OK)
			return status;
	}

	// Clear the message, as we're just going to add to it
	apps->MakeEmpty();

	BString typeString(type);
	typeString.ToLower();

	BMimeType mime(type);
	status_t status = mime.InitCheck();
	if (status != B_OK)
		return status;

	if (mime.IsSupertypeOnly()) {
		// Add the apps that support this supertype (plus their count)
		std::set<std::string> &superApps = fSupportingApps[typeString.String()];
		int32 count = 0;
		std::set<std::string>::const_iterator i;
		for (i = superApps.begin(); i != superApps.end() && status == B_OK; i++) {
			status = apps->AddString(kApplicationsField, (*i).c_str());
			count++;
		}
		if (status == B_OK)
			status = apps->AddInt32(kSupportingAppsSuperCountField, count);
	} else {
		// Add the apps that support this subtype (plus their count)
		std::set<std::string> &subApps = fSupportingApps[typeString.String()];
		int32 count = 0;
		std::set<std::string>::const_iterator i;
		for (i = subApps.begin(); i != subApps.end() && status == B_OK; i++) {
			status = apps->AddString(kApplicationsField, (*i).c_str());
			count++;
		}
		if (status == B_OK)
			status = apps->AddInt32(kSupportingAppsSubCountField, count);

		// Now add any apps that support the supertype, but not the
		// subtype (plus their count).
		BMimeType superMime;
		status = mime.GetSupertype(&superMime);
		if (status == B_OK)
			status = superMime.InitCheck();
		if (status == B_OK) {
			std::set<std::string> &superApps = fSupportingApps[superMime.Type()];
			count = 0;
			for (i = superApps.begin(); i != superApps.end() && status == B_OK; i++) {
				if (subApps.find(*i) == subApps.end()) {
					status = apps->AddString(kApplicationsField, (*i).c_str());
					count++;
				}
			}
			if (status == B_OK)
				status = apps->AddInt32(kSupportingAppsSuperCountField, count);
		}
	}

	return status;
}


/*! \brief Sets the list of supported types for the given application and
	updates the supporting apps mappings.

	All types listed as being supported types will including the given
	app signature in their list of supporting apps following this call.

	If \a fullSync is true, all types previously but no longer supported
	by this application with no longer list this application as a
	supporting app.

	If \a fullSync is false, said previously supported types will be
	saved to a "stranded types" mapping and appropriately synchronized
	the next time SetSupportedTypes() is called with a \c true \a fullSync
	parameter.

	The stranded types mapping is properly maintained even in the event
	of types being removed and then re-added to the list of supporting
	types with consecutive \c false \a fullSync parameters.

	\param app The application whose supported types you are setting
	\param types Pointer to a \c BMessage containing an array of supported
	             mime types in its \c Mime::kTypesField field.
	\param fullSync If \c true, \c app is removed as a supporting application
	                for any types for which it is no longer a supporting application
	                (including types which were removed as supporting types with
	                previous callsto SetSupportedTypes(..., false)). If \c false,
	                said mappings are not updated until the next SetSupportedTypes(..., true)
	                call.
*/
status_t
SupportingApps::SetSupportedTypes(const char *app, const BMessage *types, bool fullSync)
{
	if (app == NULL || types == NULL)
		return B_BAD_VALUE;

	if (!fHaveDoneFullBuild)
		return B_OK;

	std::set<std::string> oldTypes;
	std::set<std::string> &newTypes = fSupportedTypes[app];
	std::set<std::string> &strandedTypes = fStrandedTypes[app];

	// Make a copy of the previous types if we're doing a full sync
	oldTypes = newTypes;

	// Read through the list of new supported types, creating the new
	// supported types list and adding the app as a supporting app for
	// each type.
	newTypes.clear();
	BString type;
	for (int32 i = 0; types->FindString(kTypesField, i, &type) == B_OK; i++) {
		type.ToLower();
		newTypes.insert(type.String());
		AddSupportingApp(type.String(), app);
	}

	// Update the list of stranded types by removing any types that are newly
	// re-supported and adding any types that are newly un-supported
	for (std::set<std::string>::const_iterator i = newTypes.begin();
			i != newTypes.end(); i++) {
		strandedTypes.erase(*i);
	}
	for (std::set<std::string>::const_iterator i = oldTypes.begin();
			i != oldTypes.end(); i++) {
		if (newTypes.find(*i) == newTypes.end())
			strandedTypes.insert(*i);
	}

	// Now, if we're doing a full sync, remove the app as a supporting
	// app for any of its stranded types and then clear said list of
	// stranded types.
	if (fullSync) {
		for (std::set<std::string>::const_iterator i = strandedTypes.begin();
				i != strandedTypes.end(); i++) {
			RemoveSupportingApp((*i).c_str(), app);
		}
		strandedTypes.clear();
	}

	return B_OK;
}


/*! \brief Clears the given application's supported types list and optionally
	removes the application from each of said types' supporting apps list.
	\param app The application whose supported types you are clearing
	\param fullSync See SupportingApps::SetSupportedTypes()
*/
status_t
SupportingApps::DeleteSupportedTypes(const char *app, bool fullSync)
{
	BMessage types;
	return SetSupportedTypes(app, &types, fullSync);
}


/*! \brief Adds the given application signature to the set of supporting
	apps for the given type.

	\param type The full mime type
	\param app The full application signature (i.e. "application/app-subtype")
	\return
	- B_OK: success, even if the app was already in the supporting apps list
	- "error code": failure
*/
status_t
SupportingApps::AddSupportingApp(const char *type, const char *app)
{
	if (type == NULL || app == NULL)
		return B_BAD_VALUE;

	fSupportingApps[type].insert(app);
	return B_OK;
}


/*! \brief Removes the given application signature from the set of supporting
	apps for the given type.

	\param type The full mime type
	\param app The full application signature (i.e. "application/app-subtype")
	\return
	- B_OK: success, even if the app was not found in the supporting apps list
	- "error code": failure
*/
status_t
SupportingApps::RemoveSupportingApp(const char *type, const char *app)
{
	if (type == NULL || app == NULL)
		return B_BAD_VALUE;

	fSupportingApps[type].erase(app);
	return B_OK;
}


/*! \brief Crawls the mime database and builds a list of supporting application
	signatures for every supported type.
*/
status_t
SupportingApps::BuildSupportingAppsTable()
{
	fSupportedTypes.clear();
	fSupportingApps.clear();
	fStrandedTypes.clear();

	DatabaseDirectory dir;
	status_t status = dir.Init(fDatabaseLocation, "application");
	if (status != B_OK)
		return status;

	// Build the supporting apps table based on the mime database
	dir.Rewind();

	// Handle each application type
	while (true) {
		entry_ref ref;
		status = dir.GetNextRef(&ref);
		if (status < B_OK) {
			// If we've come to the end of list, it's not an error
			if (status == B_ENTRY_NOT_FOUND)
				status = B_OK;
			break;
		}

		// read application signature from file
		BString appSignature;
		BNode node(&ref);
		if (node.InitCheck() == B_OK && node.ReadAttrString(kTypeAttr,
				&appSignature) >= B_OK) {
			// Read in the list of supported types
			BMessage msg;
			if (fDatabaseLocation->ReadMessageAttribute(appSignature,
					kSupportedTypesAttr, msg) == B_OK) {
				// Iterate through the supported types, adding them to the list of
				// supported types for the application and adding the application's
				// signature to the list of supporting apps for each type
				BString type;
				std::set<std::string> &supportedTypes = fSupportedTypes[appSignature.String()];
				for (int i = 0; msg.FindString(kTypesField, i, &type) == B_OK; i++) {
					type.ToLower();
						// MIME types are case insensitive, so we lowercase everything
					supportedTypes.insert(type.String());
					AddSupportingApp(type.String(), appSignature.String());
				}
			}
		}
	}

	if (status == B_OK)
		fHaveDoneFullBuild = true;
	else
		DBG(OUT("SupportingApps::BuildSupportingAppsTable() failed: %s\n", strerror(status)));

	return status;
}


} // namespace Mime
} // namespace Storage
} // namespace BPrivate