Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
#include "nsString.h"
#include "nsMemory.h"
#include "nsIImportModule.h"
#include "nsIImportService.h"
#include "nsImportMailboxDescriptor.h"
#include "nsImportABDescriptor.h"
#include "nsIImportGeneric.h"
#include "nsImportFieldMap.h"
#include "nsICategoryManager.h"
#include "nsXPCOM.h"
#include "nsISupportsPrimitives.h"
#include "nsThreadUtils.h"
#include "ImportDebug.h"
#include "nsImportService.h"
#include "nsImportStringBundle.h"
#include "nsCRTGlue.h"
#include "nsServiceManagerUtils.h"
#include "nsComponentManagerUtils.h"
#include "nsIMsgSend.h"
#include "nsMsgUtils.h"
#include "mozilla/SimpleEnumerator.h"
mozilla::LazyLogModule IMPORTLOGMODULE("Import");
////////////////////////////////////////////////////////////////////////
nsImportService::nsImportService() {
IMPORT_LOG0("* nsImport Service Created\n");
m_didDiscovery = false;
nsresult rv = nsImportStringBundle::GetStringBundle(
IMPORT_MSGS_URL, getter_AddRefs(m_stringBundle));
if (NS_FAILED(rv))
IMPORT_LOG0("Failed to get string bundle for Importing Mail");
}
nsImportService::~nsImportService() {
IMPORT_LOG0("* nsImport Service Deleted\n");
}
NS_IMPL_ISUPPORTS(nsImportService, nsIImportService)
NS_IMETHODIMP nsImportService::DiscoverModules(void) {
m_didDiscovery = false;
return DoDiscover();
}
NS_IMETHODIMP nsImportService::CreateNewFieldMap(nsIImportFieldMap** _retval) {
return nsImportFieldMap::Create(m_stringBundle, NS_GET_IID(nsIImportFieldMap),
(void**)_retval);
}
NS_IMETHODIMP nsImportService::CreateNewMailboxDescriptor(
nsIImportMailboxDescriptor** _retval) {
return nsImportMailboxDescriptor::Create(
NS_GET_IID(nsIImportMailboxDescriptor), (void**)_retval);
}
NS_IMETHODIMP nsImportService::CreateNewABDescriptor(
nsIImportABDescriptor** _retval) {
return nsImportABDescriptor::Create(NS_GET_IID(nsIImportABDescriptor),
(void**)_retval);
}
extern nsresult NS_NewGenericMail(nsIImportGeneric** aImportGeneric);
NS_IMETHODIMP nsImportService::CreateNewGenericMail(
nsIImportGeneric** _retval) {
NS_ASSERTION(_retval != nullptr, "null ptr");
if (!_retval) return NS_ERROR_NULL_POINTER;
return NS_NewGenericMail(_retval);
}
extern nsresult NS_NewGenericAddressBooks(nsIImportGeneric** aImportGeneric);
NS_IMETHODIMP nsImportService::CreateNewGenericAddressBooks(
nsIImportGeneric** _retval) {
NS_ASSERTION(_retval != nullptr, "null ptr");
if (!_retval) return NS_ERROR_NULL_POINTER;
return NS_NewGenericAddressBooks(_retval);
}
NS_IMETHODIMP nsImportService::GetModuleCount(const char* filter,
int32_t* _retval) {
NS_ASSERTION(_retval != nullptr, "null ptr");
if (!_retval) return NS_ERROR_NULL_POINTER;
DoDiscover();
nsCString filterStr(filter);
int32_t count = 0;
for (auto& importModule : m_importModules) {
if (importModule.SupportsThings(filterStr)) count++;
}
*_retval = count;
return NS_OK;
}
ImportModuleDesc* nsImportService::GetImportModule(const char* filter,
int32_t index) {
DoDiscover();
nsCString filterStr(filter);
int32_t count = 0;
for (auto& importModule : m_importModules) {
if (importModule.SupportsThings(filterStr)) {
if (count++ == index) {
return &importModule;
}
}
}
return nullptr;
}
NS_IMETHODIMP nsImportService::GetModuleInfo(const char* filter, int32_t index,
nsAString& name,
nsAString& moduleDescription) {
ImportModuleDesc* importModule = GetImportModule(filter, index);
if (!importModule) return NS_ERROR_FAILURE;
name = importModule->GetName();
moduleDescription = importModule->GetDescription();
return NS_OK;
}
NS_IMETHODIMP nsImportService::GetModuleName(const char* filter, int32_t index,
nsAString& _retval) {
ImportModuleDesc* importModule = GetImportModule(filter, index);
if (!importModule) return NS_ERROR_FAILURE;
_retval = importModule->GetName();
return NS_OK;
}
NS_IMETHODIMP nsImportService::GetModuleDescription(const char* filter,
int32_t index,
nsAString& _retval) {
ImportModuleDesc* importModule = GetImportModule(filter, index);
if (!importModule) return NS_ERROR_FAILURE;
_retval = importModule->GetDescription();
return NS_OK;
}
class nsProxySendRunnable : public mozilla::Runnable {
public:
nsProxySendRunnable(
nsIMsgIdentity* aIdentity, nsIMsgCompFields* aMsgFields,
const char* attachment1_type, const nsACString& attachment1_body,
bool aIsDraft,
nsTArray<RefPtr<nsIMsgAttachedFile>> const& aLoadedAttachments,
nsTArray<RefPtr<nsIMsgEmbeddedImageData>> const& aEmbeddedAttachments,
nsIMsgSendListener* aListener);
NS_DECL_NSIRUNNABLE
private:
nsCOMPtr<nsIMsgIdentity> m_identity;
nsCOMPtr<nsIMsgCompFields> m_compFields;
bool m_isDraft;
nsCString m_bodyType;
nsCString m_body;
nsTArray<RefPtr<nsIMsgAttachedFile>> m_loadedAttachments;
nsTArray<RefPtr<nsIMsgEmbeddedImageData>> m_embeddedAttachments;
nsCOMPtr<nsIMsgSendListener> m_listener;
};
nsProxySendRunnable::nsProxySendRunnable(
nsIMsgIdentity* aIdentity, nsIMsgCompFields* aMsgFields,
const char* aBodyType, const nsACString& aBody, bool aIsDraft,
nsTArray<RefPtr<nsIMsgAttachedFile>> const& aLoadedAttachments,
nsTArray<RefPtr<nsIMsgEmbeddedImageData>> const& aEmbeddedAttachments,
nsIMsgSendListener* aListener)
: mozilla::Runnable("nsProxySendRunnable"),
m_identity(aIdentity),
m_compFields(aMsgFields),
m_isDraft(aIsDraft),
m_bodyType(aBodyType),
m_body(aBody),
m_loadedAttachments(aLoadedAttachments.Clone()),
m_embeddedAttachments(aEmbeddedAttachments.Clone()),
m_listener(aListener) {}
NS_IMETHODIMP nsProxySendRunnable::Run() {
nsresult rv;
nsCOMPtr<nsIMsgSend> msgSend =
do_CreateInstance("@mozilla.org/messengercompose/send;1", &rv);
NS_ENSURE_SUCCESS(rv, rv);
return msgSend->CreateRFC822Message(
m_identity, m_compFields, m_bodyType.get(), m_body, m_isDraft,
m_loadedAttachments, m_embeddedAttachments, m_listener);
}
NS_IMETHODIMP
nsImportService::CreateRFC822Message(
nsIMsgIdentity* aIdentity, nsIMsgCompFields* aMsgFields,
const char* aBodyType, const nsACString& aBody, bool aIsDraft,
nsTArray<RefPtr<nsIMsgAttachedFile>> const& aLoadedAttachments,
nsTArray<RefPtr<nsIMsgEmbeddedImageData>> const& aEmbeddedAttachments,
nsIMsgSendListener* aListener) {
RefPtr<nsProxySendRunnable> runnable = new nsProxySendRunnable(
aIdentity, aMsgFields, aBodyType, aBody, aIsDraft, aLoadedAttachments,
aEmbeddedAttachments, aListener);
// invoke the callback
return NS_DispatchToMainThread(runnable);
}
NS_IMETHODIMP nsImportService::GetModule(const char* filter, int32_t index,
nsIImportModule** _retval) {
NS_ASSERTION(_retval != nullptr, "null ptr");
if (!_retval) return NS_ERROR_NULL_POINTER;
*_retval = nullptr;
ImportModuleDesc* importModule = GetImportModule(filter, index);
if (!importModule) return NS_ERROR_FAILURE;
nsCOMPtr<nsIImportModule> modulePtr = importModule->GetModule();
modulePtr.forget(_retval);
return NS_OK;
}
nsresult nsImportService::DoDiscover(void) {
if (m_didDiscovery) return NS_OK;
m_importModules.Clear();
nsresult rv;
nsCOMPtr<nsICategoryManager> catMan =
do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsISimpleEnumerator> e;
rv = catMan->EnumerateCategory("mailnewsimport", getter_AddRefs(e));
NS_ENSURE_SUCCESS(rv, rv);
for (auto& key : mozilla::SimpleEnumerator<nsISupportsCString>(e)) {
nsCString keyStr;
key->ToString(getter_Copies(keyStr));
nsCString contractIdStr;
rv = catMan->GetCategoryEntry("mailnewsimport", keyStr, contractIdStr);
if (NS_SUCCEEDED(rv)) LoadModuleInfo(contractIdStr);
}
m_didDiscovery = true;
return NS_OK;
}
nsresult nsImportService::LoadModuleInfo(const nsCString& contractId) {
// load the component and get all of the info we need from it....
nsresult rv;
nsCOMPtr<nsIImportModule> module = do_CreateInstance(contractId.get(), &rv);
if (NS_FAILED(rv)) return rv;
m_importModules.EmplaceBack(module);
return NS_OK;
}
ImportModuleDesc::ImportModuleDesc(nsIImportModule* importModule)
: m_pModule(importModule) {
nsresult rv;
rv = importModule->GetName(getter_Copies(m_name));
if (NS_FAILED(rv)) m_name.AssignLiteral("Unknown");
rv = importModule->GetDescription(getter_Copies(m_description));
if (NS_FAILED(rv)) m_description.AssignLiteral("Unknown description");
importModule->GetSupports(getter_Copies(m_supports));
#ifdef IMPORT_DEBUG
IMPORT_LOG3("* nsImportService registered import module: %s, %s, %s\n",
NS_LossyConvertUTF16toASCII(m_name).get(),
NS_LossyConvertUTF16toASCII(m_description).get(),
m_supports.get());
#endif
}
bool ImportModuleDesc::SupportsThings(const nsACString& thing) {
for (auto& item : m_supports.Split(',')) {
if (item == thing) return true;
}
return false;
}