diff options
Diffstat (limited to 'dom/system/gonk/AutoMounter.cpp')
| -rw-r--r-- | dom/system/gonk/AutoMounter.cpp | 1496 |
1 files changed, 1496 insertions, 0 deletions
diff --git a/dom/system/gonk/AutoMounter.cpp b/dom/system/gonk/AutoMounter.cpp new file mode 100644 index 000000000..52c4554fb --- /dev/null +++ b/dom/system/gonk/AutoMounter.cpp @@ -0,0 +1,1496 @@ +/* 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 file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include <errno.h> +#include <fcntl.h> +#include <pthread.h> +#include <signal.h> +#include <string.h> +#include <strings.h> +#include <unistd.h> +#include <sys/statfs.h> + +#include <arpa/inet.h> +#include <linux/types.h> +#include <linux/netlink.h> +#include <netinet/in.h> +#include <sys/socket.h> +#include <android/log.h> +#include <cutils/properties.h> + +#include "AutoMounter.h" +#include "nsVolumeService.h" +#include "AutoMounterSetting.h" +#include "base/message_loop.h" +#include "base/task.h" +#include "mozilla/AutoRestore.h" +#include "mozilla/FileUtils.h" +#include "mozilla/Hal.h" +#include "mozilla/StaticPtr.h" +#include "MozMtpServer.h" +#include "MozMtpStorage.h" +#include "nsCharSeparatedTokenizer.h" +#include "nsMemory.h" +#include "nsString.h" +#include "nsThreadUtils.h" +#include "nsXULAppAPI.h" +#include "OpenFileFinder.h" +#include "Volume.h" +#include "VolumeManager.h" +#include "nsIStatusReporter.h" + +USING_MTP_NAMESPACE + +/************************************************************************** +* +* The following "switch" files are available for monitoring usb +* connections: +* +* /sys/devices/virtual/switch/usb_connected/state +* /sys/devices/virtual/switch/usb_configuration/state +* +* Under gingerbread, only the usb_configuration seems to be available. +* Starting with honeycomb, usb_connected was also added. +* +* When a cable insertion/removal occurs, then a uevent similar to the +* following will be generted: +* +* change@/devices/virtual/switch/usb_configuration +* ACTION=change +* DEVPATH=/devices/virtual/switch/usb_configuration +* SUBSYSTEM=switch +* SWITCH_NAME=usb_configuration +* SWITCH_STATE=0 +* SEQNUM=5038 +* +* SWITCH_STATE will be 0 after a removal and 1 after an insertion +* +**************************************************************************/ + +#define USB_CONFIGURATION_SWITCH_NAME NS_LITERAL_STRING("usb_configuration") + +#define GB_SYS_UMS_ENABLE "/sys/devices/virtual/usb_composite/usb_mass_storage/enable" +#define GB_SYS_USB_CONFIGURED "/sys/devices/virtual/switch/usb_configuration/state" + +#define ICS_SYS_USB_FUNCTIONS "/sys/devices/virtual/android_usb/android0/functions" +#define ICS_SYS_UMS_DIRECTORY "/sys/devices/virtual/android_usb/android0/f_mass_storage" +#define ICS_SYS_MTP_DIRECTORY "/sys/devices/virtual/android_usb/android0/f_mtp" +#define ICS_SYS_USB_STATE "/sys/devices/virtual/android_usb/android0/state" + +#undef USE_DEBUG // MozMtpDatabase.h also defines USE_DEBUG +#define USE_DEBUG 0 + +#undef LOG +#undef LOGW +#undef ERR +#define LOG(args...) __android_log_print(ANDROID_LOG_INFO, "AutoMounter", ## args) +#define LOGW(args...) __android_log_print(ANDROID_LOG_WARN, "AutoMounter", ## args) +#define ERR(args...) __android_log_print(ANDROID_LOG_ERROR, "AutoMounter", ## args) + +#undef DBG +#if USE_DEBUG +#define DBG(args...) __android_log_print(ANDROID_LOG_DEBUG, "AutoMounter" , ## args) +#else +#define DBG(args...) +#endif + +namespace mozilla { +namespace system { + +#define SYS_USB_CONFIG "sys.usb.config" +#define PERSIST_SYS_USB_CONFIG "persist.sys.usb.config" + +#define USB_FUNC_ADB "adb" +#define USB_FUNC_MTP "mtp" +#define USB_FUNC_NONE "none" +#define USB_FUNC_RNDIS "rndis" +#define USB_FUNC_UMS "mass_storage" +#define USB_FUNC_DEFAULT "default" + +class AutoMounter; + +static void SetAutoMounterStatus(int32_t aStatus); + +/***************************************************************************/ + +inline const char* SwitchStateStr(const hal::SwitchEvent& aEvent) +{ + return aEvent.status() == hal::SWITCH_STATE_ON ? "plugged" : "unplugged"; +} + +/***************************************************************************/ + +static bool +IsUsbCablePluggedIn() +{ +#if 0 + // Use this code when bug 745078 gets fixed (or use whatever the + // appropriate method is) + return GetCurrentSwitchEvent(SWITCH_USB) == hal::SWITCH_STATE_ON; +#else + // Until then, just go read the file directly + if (access(ICS_SYS_USB_STATE, F_OK) == 0) { + char usbState[20]; + if (ReadSysFile(ICS_SYS_USB_STATE, usbState, sizeof(usbState))) { + DBG("IsUsbCablePluggedIn: state = '%s'", usbState); + return strcmp(usbState, "CONFIGURED") == 0 || + strcmp(usbState, "CONNECTED") == 0; + } + ERR("Error reading file '%s': %s", ICS_SYS_USB_STATE, strerror(errno)); + return false; + } + bool configured; + if (ReadSysFile(GB_SYS_USB_CONFIGURED, &configured)) { + return configured; + } + ERR("Error reading file '%s': %s", GB_SYS_USB_CONFIGURED, strerror(errno)); + return false; +#endif +} + +static bool +IsUsbConfigured() +{ + if (access(ICS_SYS_USB_STATE, F_OK) == 0) { + char usbState[20]; + if (ReadSysFile(ICS_SYS_USB_STATE, usbState, sizeof(usbState))) { + DBG("IsUsbConfigured: state = '%s'", usbState); + return strcmp(usbState, "CONFIGURED") == 0; + } + ERR("Error reading file '%s': %s", ICS_SYS_USB_STATE, strerror(errno)); + return false; + } + bool configured; + if (ReadSysFile(GB_SYS_USB_CONFIGURED, &configured)) { + return configured; + } + ERR("Error reading file '%s': %s", GB_SYS_USB_CONFIGURED, strerror(errno)); + return false; +} + +/***************************************************************************/ + +// The AutoVolumeManagerStateObserver allows the AutoMounter to know when +// the volume manager changes state (i.e. it has finished initialization) +class AutoVolumeManagerStateObserver : public VolumeManager::StateObserver +{ +public: + virtual void Notify(const VolumeManager::StateChangedEvent& aEvent); +}; + +// The AutoVolumeEventObserver allows the AutoMounter to know about card +// insertion and removal, as well as state changes in the volume. +class AutoVolumeEventObserver : public Volume::EventObserver +{ +public: + virtual void Notify(Volume* const& aEvent); +}; + +class AutoMounterResponseCallback : public VolumeResponseCallback +{ +public: + AutoMounterResponseCallback() + : mErrorCount(0) + { + } + +protected: + virtual void ResponseReceived(const VolumeCommand* aCommand); + +private: + const static int kMaxErrorCount = 3; // Max number of errors before we give up + + int mErrorCount; +}; + +/***************************************************************************/ + +class AutoMounter +{ +public: + NS_INLINE_DECL_REFCOUNTING(AutoMounter) + + typedef nsTArray<RefPtr<Volume>> VolumeArray; + + AutoMounter() + : mState(STATE_IDLE), + mResponseCallback(new AutoMounterResponseCallback), + mMode(AUTOMOUNTER_DISABLE) + { + VolumeManager::RegisterStateObserver(&mVolumeManagerStateObserver); + Volume::RegisterVolumeObserver(&mVolumeEventObserver, "AutoMounter"); + + // It's possible that the VolumeManager is already in the READY state, + // so we call CheckVolumeSettings here to cover that case. Otherwise, + // we'll pick it up when the VolumeManage state changes to VOLUMES_READY. + CheckVolumeSettings(); + + DBG("Calling UpdateState from constructor"); + UpdateState(); + } + + void CheckVolumeSettings() + { + if (VolumeManager::State() != VolumeManager::VOLUMES_READY) { + DBG("CheckVolumeSettings: VolumeManager is NOT READY yet"); + return; + } + DBG("CheckVolumeSettings: VolumeManager is READY"); + + // The VolumeManager knows about all of the volumes from vold. We now + // know the names of all of the volumes, so we can find out what the + // initial sharing settings are set to. + + VolumeManager::VolumeArray::size_type numVolumes = VolumeManager::NumVolumes(); + VolumeManager::VolumeArray::index_type i; + for (i = 0; i < numVolumes; i++) { + RefPtr<Volume> vol = VolumeManager::GetVolume(i); + if (vol) { + // We need to pick up the intial value of the + // ums.volume.NAME.enabled setting. + AutoMounterSetting::CheckVolumeSettings(vol->Name()); + + // Note: eventually CheckVolumeSettings will call + // AutoMounter::SetSharingMode, which will in turn call + // UpdateState if needed. + } + } + } + + void UpdateState(); + void GetStatus(bool& umsAvail, bool& umsConfigured, bool& umsEnabled, bool& mtpAvail, + bool& mtpConfigured, bool& mtpEnabled, bool& rndisConfigured); + + nsresult Dump(nsACString& desc); + + void ConfigureUsbFunction(const char* aUsbFunc); + + bool StartMtpServer(); + void StopMtpServer(); + + void StartUmsSharing(); + void StopUmsSharing(); + + + const char* ModeStr(int32_t aMode) + { + switch (aMode) { + case AUTOMOUNTER_DISABLE: return "Disable"; + case AUTOMOUNTER_ENABLE_UMS: return "Enable-UMS"; + case AUTOMOUNTER_DISABLE_WHEN_UNPLUGGED: return "DisableWhenUnplugged"; + case AUTOMOUNTER_ENABLE_MTP: return "Enable-MTP"; + } + return "??? Unknown ???"; + } + + bool IsModeEnabled(int32_t aMode) + { + return aMode == AUTOMOUNTER_ENABLE_MTP || + aMode == AUTOMOUNTER_ENABLE_UMS; + } + + void SetMode(int32_t aMode) + { + if ((aMode == AUTOMOUNTER_DISABLE_WHEN_UNPLUGGED) && + (mMode == AUTOMOUNTER_DISABLE)) { + // If it's already disabled, then leave it as disabled. + // AUTOMOUNTER_DISABLE_WHEN_UNPLUGGED implies "enabled until unplugged" + aMode = AUTOMOUNTER_DISABLE; + } + + if (aMode == AUTOMOUNTER_DISABLE && + mMode == AUTOMOUNTER_ENABLE_UMS && IsUsbCablePluggedIn()) { + // On many devices (esp non-Samsung), we can't force the disable, so we + // need to defer until the USB cable is actually unplugged. + // See bug 777043. + // + // Otherwise our attempt to disable it will fail, and we'll wind up in a bad + // state where the AutoMounter thinks that Sharing has been turned off, but + // the files are actually still being Shared because the attempt to unshare + // failed. + LOG("Attempting to disable UMS. Deferring until USB cable is unplugged."); + aMode = AUTOMOUNTER_DISABLE_WHEN_UNPLUGGED; + } + + if (aMode != mMode) { + LOG("Changing mode from '%s' to '%s'", ModeStr(mMode), ModeStr(aMode)); + mMode = aMode; + DBG("Calling UpdateState due to mode set to %d", mMode); + UpdateState(); + } + } + + void SetSharingMode(const nsACString& aVolumeName, bool aAllowSharing) + { + RefPtr<Volume> vol = VolumeManager::FindVolumeByName(aVolumeName); + if (!vol) { + return; + } + if (vol->IsSharingEnabled() == aAllowSharing) { + return; + } + vol->SetUnmountRequested(false); + vol->SetMountRequested(false); + vol->SetSharingEnabled(aAllowSharing); + DBG("Calling UpdateState due to volume %s sharing set to %d", + vol->NameStr(), (int)aAllowSharing); + UpdateState(); + } + + void FormatVolume(const nsACString& aVolumeName) + { + RefPtr<Volume> vol = VolumeManager::FindVolumeByName(aVolumeName); + if (!vol) { + return; + } + if (vol->IsFormatRequested()) { + return; + } + vol->SetUnmountRequested(false); + vol->SetMountRequested(false); + vol->SetFormatRequested(true); + DBG("Calling UpdateState due to volume %s formatting set to %d", + vol->NameStr(), (int)vol->IsFormatRequested()); + UpdateState(); + } + + void MountVolume(const nsACString& aVolumeName) + { + RefPtr<Volume> vol = VolumeManager::FindVolumeByName(aVolumeName); + if (!vol) { + return; + } + vol->SetUnmountRequested(false); + if (vol->IsMountRequested() || vol->mState == nsIVolume::STATE_MOUNTED) { + return; + } + vol->SetMountRequested(true); + DBG("Calling UpdateState due to volume %s mounting set to %d", + vol->NameStr(), (int)vol->IsMountRequested()); + UpdateState(); + } + + void UnmountVolume(const nsACString& aVolumeName) + { + RefPtr<Volume> vol = VolumeManager::FindVolumeByName(aVolumeName); + if (!vol) { + return; + } + if (vol->IsUnmountRequested()) { + return; + } + vol->SetMountRequested(false); + vol->SetUnmountRequested(true); + DBG("Calling UpdateState due to volume %s unmounting set to %d", + vol->NameStr(), (int)vol->IsUnmountRequested()); + UpdateState(); + } + +protected: + ~AutoMounter() + { + Volume::UnregisterVolumeObserver(&mVolumeEventObserver, "AutoMounter"); + VolumeManager::UnregisterStateObserver(&mVolumeManagerStateObserver); + } + +private: + + enum STATE + { + // IDLE - Nothing is being shared + STATE_IDLE, + + // We've detected that conditions are right to enable mtp. So we've + // set sys.usb.config to include mtp, and we're waiting for the USB + // subsystem to be "configured". Once mtp shows up in + // then we know + // that its been configured and we can open /dev/mtp_usb + STATE_MTP_CONFIGURING, + + // mtp has been configured (i.e. mtp now shows up in + // /sys/devices/virtual/android_usb/android0/functions so we can start + // the mtp server. + STATE_MTP_STARTED, + + // The mtp server has reported sessionStarted. We'll leave this state + // when we receive sessionEnded. + STATE_MTP_CONNECTED, + + // We've added mass_storage (aka UMS) to sys.usb.config and we're waiting for + // mass_storage to appear in /sys/devices/virtual/android_usb/android0/functions + STATE_UMS_CONFIGURING, + + // mass_storage has been configured and we can start sharing once the user + // enables it. + STATE_UMS_CONFIGURED, + + // USB Tethering is enabled + STATE_RNDIS_CONFIGURED, + }; + + const char *StateStr(STATE aState) + { + switch (aState) { + case STATE_IDLE: return "IDLE"; + case STATE_MTP_CONFIGURING: return "MTP_CONFIGURING"; + case STATE_MTP_CONNECTED: return "MTP_CONNECTED"; + case STATE_MTP_STARTED: return "MTP_STARTED"; + case STATE_UMS_CONFIGURING: return "UMS_CONFIGURING"; + case STATE_UMS_CONFIGURED: return "UMS_CONFIGURED"; + case STATE_RNDIS_CONFIGURED: return "RNDIS_CONFIGURED"; + } + return "STATE_???"; + } + + void SetState(STATE aState) + { + const char *oldStateStr = StateStr(mState); + mState = aState; + const char *newStateStr = StateStr(mState); + LOG("AutoMounter state changed from %s to %s", oldStateStr, newStateStr); + } + + STATE mState; + + AutoVolumeEventObserver mVolumeEventObserver; + AutoVolumeManagerStateObserver mVolumeManagerStateObserver; + RefPtr<VolumeResponseCallback> mResponseCallback; + int32_t mMode; + MozMtpStorage::Array mMozMtpStorage; +}; + +static StaticRefPtr<AutoMounter> sAutoMounter; +static StaticRefPtr<MozMtpServer> sMozMtpServer; + +// The following is for status reporter +enum STATE_REPORTER_STATE +{ + REPORTER_UNREGISTERED, + REPORTER_REGISTERED +}; + +static int status_reporter_progress = REPORTER_UNREGISTERED; +nsresult getState(nsACString &desc) +{ + sAutoMounter->Dump(desc); + return NS_OK; +} +NS_STATUS_REPORTER_IMPLEMENT(AutoMounter, "AutoMounter", getState); + +/***************************************************************************/ + +void +AutoVolumeManagerStateObserver::Notify(const VolumeManager::StateChangedEvent &) +{ + LOG("VolumeManager state changed event: %s", VolumeManager::StateStr()); + + if (!sAutoMounter) { + return; + } + + // In the event that the VolumeManager just entered the VOLUMES_READY state, + // we call CheckVolumeSettings here (it's possible that this method never + // gets called if the VolumeManager was already in the VOLUMES_READY state + // by the time the AutoMounter was constructed). + sAutoMounter->CheckVolumeSettings(); + + DBG("Calling UpdateState due to VolumeManagerStateObserver"); + sAutoMounter->UpdateState(); +} + +void +AutoVolumeEventObserver::Notify(Volume * const &) +{ + if (!sAutoMounter) { + return; + } + DBG("Calling UpdateState due to VolumeEventStateObserver"); + sAutoMounter->UpdateState(); +} + +void +AutoMounterResponseCallback::ResponseReceived(const VolumeCommand* aCommand) +{ + + if (WasSuccessful()) { + DBG("Calling UpdateState due to Volume::OnSuccess"); + mErrorCount = 0; + sAutoMounter->UpdateState(); + return; + } + ERR("Command '%s' failed: %d '%s'", + aCommand->CmdStr(), ResponseCode(), ResponseStr().get()); + + if (++mErrorCount < kMaxErrorCount) { + DBG("Calling UpdateState due to VolumeResponseCallback::OnError"); + sAutoMounter->UpdateState(); + } +} + +static bool +IsUsbFunctionEnabled(const char* aConfig, const char* aUsbFunc) +{ + nsAutoCString config(aConfig); + nsCCharSeparatedTokenizer tokenizer(config, ','); + + while (tokenizer.hasMoreTokens()) { + nsAutoCString token(tokenizer.nextToken()); + if (token.Equals(aUsbFunc)) { + DBG("IsUsbFunctionEnabled('%s', '%s'): returning true", aConfig, aUsbFunc); + return true; + } + } + DBG("IsUsbFunctionEnabled('%s', '%s'): returning false", aConfig, aUsbFunc); + return false; +} + +static void +SetUsbFunction(const char* aUsbFunc) +{ + char oldSysUsbConfig[PROPERTY_VALUE_MAX]; + property_get(SYS_USB_CONFIG, oldSysUsbConfig, ""); + + if (strcmp(oldSysUsbConfig, USB_FUNC_NONE) == 0) { + // It's quite possible that sys.usb.config may have the value "none". We + // convert that to an empty string here, and at the end we convert the + // empty string back to "none". + oldSysUsbConfig[0] = '\0'; + } + + if (IsUsbFunctionEnabled(oldSysUsbConfig, aUsbFunc)) { + // The function is already configured. Nothing else to do. + DBG("SetUsbFunction('%s') - already set - nothing to do", aUsbFunc); + return; + } + + char newSysUsbConfig[PROPERTY_VALUE_MAX]; + + if (strcmp(aUsbFunc, USB_FUNC_MTP) == 0) { + // We're enabling MTP. For this we'll wind up using mtp, or mtp,adb + strlcpy(newSysUsbConfig, USB_FUNC_MTP, sizeof(newSysUsbConfig)); + } else if (strcmp(aUsbFunc, USB_FUNC_UMS) == 0) { + // We're enabling UMS. For this we make the assumption that the persisted + // property has mass_storage enabled. + property_get(PERSIST_SYS_USB_CONFIG, newSysUsbConfig, ""); + } else if (strcmp(aUsbFunc, USB_FUNC_DEFAULT) == 0) { + // Set the property as PERSIST_SYS_USB_CONFIG + property_get(PERSIST_SYS_USB_CONFIG, newSysUsbConfig, ""); + } else { + printf_stderr("AutoMounter::SetUsbFunction Unrecognized aUsbFunc '%s'\n", aUsbFunc); + MOZ_ASSERT(0); + return; + } + + // Make sure the new value that we write into sys.usb.config keeps the adb + // (or non-adb) of the current string. + + if (IsUsbFunctionEnabled(oldSysUsbConfig, USB_FUNC_ADB)) { + // ADB was turned on - keep it on. + if (!IsUsbFunctionEnabled(newSysUsbConfig, USB_FUNC_ADB)) { + // Add adb to the new string + strlcat(newSysUsbConfig, ",", sizeof(newSysUsbConfig)); + strlcat(newSysUsbConfig, USB_FUNC_ADB, sizeof(newSysUsbConfig)); + } + } else { + // ADB was turned off - keep it off + if (IsUsbFunctionEnabled(newSysUsbConfig, USB_FUNC_ADB)) { + // Remove ADB from the new string. + if (strcmp(newSysUsbConfig, USB_FUNC_ADB) == 0) { + newSysUsbConfig[0] = '\0'; + } else { + nsAutoCString withoutAdb(newSysUsbConfig); + withoutAdb.ReplaceSubstring( "," USB_FUNC_ADB, ""); + strlcpy(newSysUsbConfig, withoutAdb.get(), sizeof(newSysUsbConfig)); + } + } + } + + // If the persisted function didn't have mass_storage (this happens on + // the nexus 4/5, then we can get to here and have oldSysUsbConfig equal + // to newSysUsbConfig. So we need to check for that. + + if (strcmp(oldSysUsbConfig, newSysUsbConfig) == 0) { + DBG("SetUsbFunction('%s') %s is already set to '%s' - nothing to do", + aUsbFunc, SYS_USB_CONFIG, newSysUsbConfig); + return; + } + + if (newSysUsbConfig[0] == '\0') { + // Convert the empty string back to the string "none" + strlcpy(newSysUsbConfig, USB_FUNC_NONE, sizeof(newSysUsbConfig)); + } + LOG("SetUsbFunction(%s) %s from '%s' to '%s'", aUsbFunc, SYS_USB_CONFIG, + oldSysUsbConfig, newSysUsbConfig); + property_set(SYS_USB_CONFIG, newSysUsbConfig); +} + +bool +AutoMounter::StartMtpServer() +{ + if (sMozMtpServer) { + // Mtp Server is already running - nothing to do + return true; + } + LOG("Starting MtpServer"); + + // For debugging, Change the #if 0 to #if 1, and then attach gdb during + // the 5 second interval below. Otherwise, configuring MTP will cause adb + // (and thus gdb) to get bounced. +#if 0 + LOG("Sleeping"); + PRTime now = PR_Now(); + PRTime stopTime = now + 5000000; + while (PR_Now() < stopTime) { + LOG("Sleeping..."); + sleep(1); + } + LOG("Sleep done"); +#endif + + sMozMtpServer = new MozMtpServer(); + if (!sMozMtpServer->Init()) { + sMozMtpServer = nullptr; + return false; + } + + VolumeArray::index_type volIndex; + VolumeArray::size_type numVolumes = VolumeManager::NumVolumes(); + for (volIndex = 0; volIndex < numVolumes; volIndex++) { + RefPtr<Volume> vol = VolumeManager::GetVolume(volIndex); + RefPtr<MozMtpStorage> storage = new MozMtpStorage(vol, sMozMtpServer); + mMozMtpStorage.AppendElement(storage); + } + + sMozMtpServer->Run(); + return true; +} + +void +AutoMounter::StopMtpServer() +{ + LOG("Stopping MtpServer"); + + mMozMtpStorage.Clear(); + sMozMtpServer = nullptr; +} + +/***************************************************************************/ + +void +AutoMounter::UpdateState() +{ + static bool inUpdateState = false; + if (inUpdateState) { + // When UpdateState calls SetISharing, this causes a volume state + // change to occur, which would normally cause UpdateState to be called + // again. We want the volume state change to go out (so that device + // storage will see the change in sharing state), but since we're + // already in UpdateState we just want to prevent recursion from screwing + // things up. + return; + } + AutoRestore<bool> inUpdateStateDetector(inUpdateState); + inUpdateState = true; + + MOZ_ASSERT(MessageLoop::current() == XRE_GetIOMessageLoop()); + + // If the following preconditions are met: + // - UMS is available (i.e. compiled into the kernel) + // - UMS is enabled + // - AutoMounter is enabled + // - USB cable is plugged in + // then we will try to unmount and share + // otherwise we will try to unshare and mount. + + if (VolumeManager::State() != VolumeManager::VOLUMES_READY) { + // The volume manager isn't in a ready state, so there + // isn't anything else that we can do. + LOG("UpdateState: VolumeManager not ready yet"); + return; + } + + if (mResponseCallback->IsPending()) { + // We only deal with one outstanding volume command at a time, + // so we need to wait for it to finish. + return; + } + + // Calling setprop sys.usb.config mtp,adb (or adding mass_storage) will + // cause /sys/devices/virtual/android_usb/android0/state to go: + // CONFIGURED -> DISCONNECTED -> CONNECTED -> CONFIGURED + // + // Since IsUsbCablePluggedIn returns state == CONFIGURED, it will look + // like a cable pull and replugin. + bool umsAvail, umsConfigured, umsEnabled; + bool mtpAvail, mtpConfigured, mtpEnabled; + bool rndisConfigured; + bool usbCablePluggedIn = IsUsbCablePluggedIn(); + GetStatus(umsAvail, umsConfigured, umsEnabled, mtpAvail, + mtpConfigured, mtpEnabled, rndisConfigured); + bool enabled = mtpEnabled || umsEnabled; + + if (mMode == AUTOMOUNTER_DISABLE_WHEN_UNPLUGGED) { + // DISABLE_WHEN_UNPLUGGED implies already enabled. + enabled = usbCablePluggedIn; + if (!usbCablePluggedIn) { + mMode = AUTOMOUNTER_DISABLE; + mtpEnabled = false; + umsEnabled = false; + } + } + + DBG("UpdateState: ums:A%dC%dE%d mtp:A%dC%dE%d rndis:%d mode:%d usb:%d mState:%s", + umsAvail, umsConfigured, umsEnabled, + mtpAvail, mtpConfigured, mtpEnabled, rndisConfigured, + mMode, usbCablePluggedIn, StateStr(mState)); + + switch (mState) { + + case STATE_IDLE: + if (!usbCablePluggedIn) { + // Stay in the IDLE state. We'll get a CONNECTED or CONFIGURED + // UEvent when the usb cable is plugged in. + break; + } + if (rndisConfigured) { + // USB Tethering uses RNDIS. We'll just wait until its turned off. + SetState(STATE_RNDIS_CONFIGURED); + break; + } + if (mtpEnabled) { + if (mtpConfigured) { + // The USB layer has already been configured. Now we can go ahead + // and start the MTP server. This particular codepath will not + // normally be taken, but it could happen if you stop and restart + // b2g while sys.usb.config is set to enable mtp. + if (StartMtpServer()) { + SetState(STATE_MTP_STARTED); + } else { + if (umsAvail) { + // Unable to start MTP. Go back to UMS. + LOG("UpdateState: StartMtpServer failed, switch to UMS"); + SetUsbFunction(USB_FUNC_UMS); + SetState(STATE_UMS_CONFIGURING); + } else { + LOG("UpdateState: StartMtpServer failed, keep idle state"); + SetUsbFunction(USB_FUNC_DEFAULT); + } + } + } else { + // We need to configure USB to use mtp. Wait for it to be configured + // before we start the MTP server. + SetUsbFunction(USB_FUNC_MTP); + SetState(STATE_MTP_CONFIGURING); + } + } else if (umsConfigured) { + // UMS is already configured. + SetState(STATE_UMS_CONFIGURED); + } else if (umsAvail) { + // We do this whether or not UMS is enabled. With UMS, it's the + // sharing of the volume which is significant. What is important + // is that we don't leave it in MTP mode when MTP isn't enabled. + SetUsbFunction(USB_FUNC_UMS); + SetState(STATE_UMS_CONFIGURING); + } + break; + + case STATE_MTP_CONFIGURING: + // While configuring, the USB configuration state will change from + // CONFIGURED -> CONNECTED -> DISCONNECTED -> CONNECTED -> CONFIGURED + // so we don't check for cable unplugged here. + if (mtpEnabled && mtpConfigured) { + // The USB layer has been configured. Now we can go ahead and start + // the MTP server. + if (StartMtpServer()) { + SetState(STATE_MTP_STARTED); + } else { + // Unable to start MTP. Go back to UMS. + SetUsbFunction(USB_FUNC_UMS); + SetState(STATE_UMS_CONFIGURING); + } + break; + } + if (rndisConfigured) { + SetState(STATE_RNDIS_CONFIGURED); + break; + } + break; + + case STATE_MTP_STARTED: + if (usbCablePluggedIn && mtpConfigured && mtpEnabled) { + // Everything is still good. Leave the MTP server running + break; + } + DBG("STATE_MTP_STARTED: About to StopMtpServer " + "mtpConfigured = %d mtpEnabled = %d usbCablePluggedIn: %d", + mtpConfigured, mtpEnabled, usbCablePluggedIn); + StopMtpServer(); + if (rndisConfigured) { + SetState(STATE_RNDIS_CONFIGURED); + break; + } + if (umsAvail) { + // Switch back to UMS + SetUsbFunction(USB_FUNC_UMS); + SetState(STATE_UMS_CONFIGURING); + break; + } + + // if ums/rndis is not available and mtp is disable, + // restore the usb function as PERSIST_SYS_USB_CONFIG. + SetUsbFunction(USB_FUNC_DEFAULT); + SetState(STATE_IDLE); + break; + + case STATE_UMS_CONFIGURING: + if (mtpEnabled) { + // MTP was enabled. Start reconfiguring. + SetState(STATE_MTP_CONFIGURING); + SetUsbFunction(USB_FUNC_MTP); + break; + } + if (rndisConfigured) { + SetState(STATE_RNDIS_CONFIGURED); + break; + } + // While configuring, the USB configuration state will change from + // CONFIGURED -> CONNECTED -> DISCONNECTED -> CONNECTED -> CONFIGURED + // so we don't check for cable unplugged here. However, having said + // that, we'll often sit in this state while the cable is unplugged, + // since we might not get any events until the cable gets plugged back + // in. This is why we need to check for mtpEnabled once we get the + // configured event. + if (umsConfigured) { + SetState(STATE_UMS_CONFIGURED); + } + break; + + case STATE_UMS_CONFIGURED: + if (usbCablePluggedIn) { + if (mtpEnabled) { + // MTP was enabled. Start reconfiguring. + SetState(STATE_MTP_CONFIGURING); + SetUsbFunction(USB_FUNC_MTP); + break; + } + if (umsConfigured && umsEnabled) { + // This is the normal state when UMS is enabled. + break; + } + } + if (rndisConfigured) { + SetState(STATE_RNDIS_CONFIGURED); + break; + } + SetState(STATE_IDLE); + break; + + case STATE_RNDIS_CONFIGURED: + if (usbCablePluggedIn && rndisConfigured) { + // Normal state when RNDIS is enabled. + break; + } + SetState(STATE_IDLE); + break; + + default: + SetState(STATE_IDLE); + break; + } + + bool tryToShare = umsEnabled && usbCablePluggedIn; + LOG("UpdateState: ums:A%dC%dE%d mtp:A%dC%dE%d mode:%d usb:%d tryToShare:%d state:%s", + umsAvail, umsConfigured, umsEnabled, + mtpAvail, mtpConfigured, mtpEnabled, + mMode, usbCablePluggedIn, tryToShare, StateStr(mState)); + + bool filesOpen = false; + static unsigned filesOpenDelayCount = 0; + VolumeArray::index_type volIndex; + VolumeArray::size_type numVolumes = VolumeManager::NumVolumes(); + for (volIndex = 0; volIndex < numVolumes; volIndex++) { + RefPtr<Volume> vol = VolumeManager::GetVolume(volIndex); + Volume::STATE volState = vol->State(); + + if (vol->State() == nsIVolume::STATE_MOUNTED) { + LOG("UpdateState: Volume %s is %s and %s @ %s gen %d locked %d sharing %s", + vol->NameStr(), vol->StateStr(), + vol->MediaPresent() ? "inserted" : "missing", + vol->MountPoint().get(), vol->MountGeneration(), + (int)vol->IsMountLocked(), + vol->CanBeShared() ? (vol->IsSharingEnabled() ? + (vol->IsSharing() ? "en-y" : "en-n") : "dis") : "x"); + if (vol->IsSharing() && !usbCablePluggedIn) { + // We call SetIsSharing(true) below to indicate intent to share. This + // causes a state change which notifys apps, and they'll close any + // open files, which will initiate the change away from the mounted + // state and into the sharing state. Normally, when the volume + // transitions back to the mounted state, then vol->mIsSharing gets set + // to false. However, if the user pulls the USB cable before we + // actually start sharing, then the volume never actually leaves + // the mounted state (and hence never transitions from + // sharing -> mounted), and mIsSharing never gets set back to false. + // So we clear mIsSharing here. + vol->SetIsSharing(false); + } + } else { + LOG("UpdateState: Volume %s is %s and %s", vol->NameStr(), vol->StateStr(), + vol->MediaPresent() ? "inserted" : "missing"); + } + if (!vol->MediaPresent()) { + // No media - nothing we can do + continue; + } + + if (vol->State() == nsIVolume::STATE_CHECKMNT) { + // vold reports the volume is "Mounted". Need to check if the volume is + // accessible by statfs(). Once it can be accessed, set the volume as + // STATE_MOUNTED, otherwise, post a delay task of UpdateState to check it + // again. + struct statfs fsbuf; + int rc = MOZ_TEMP_FAILURE_RETRY(statfs(vol->MountPoint().get(), &fsbuf)); + if (rc == -1) { + // statfs() failed. Stay in STATE_CHECKMNT. Any failures here + // are probably non-recoverable, so we need to wait until + // something else changes the state back to IDLE/UNMOUNTED, etc. + ERR("statfs failed for '%s': errno = %d (%s)", vol->NameStr(), errno, strerror(errno)); + continue; + } + static int delay = 250; + if (fsbuf.f_blocks == 0) { + if (delay <= 4000) { + LOG("UpdateState: Volume '%s' is inaccessible, checking again in %d msec", vol->NameStr(), delay); + MessageLoopForIO::current()-> + PostDelayedTask(NewRunnableMethod(this, &AutoMounter::UpdateState), + delay); + delay *= 2; + } else { + LOG("UpdateState: Volume '%s' is inaccessible, giving up", vol->NameStr()); + } + continue; + } else { + delay = 250; + vol->SetState(nsIVolume::STATE_MOUNTED); + } + } + + if ((tryToShare && vol->IsSharingEnabled()) || + vol->IsFormatRequested() || + vol->IsUnmountRequested()) { + switch (volState) { + // We're going to try to unmount the volume + case nsIVolume::STATE_MOUNTED: { + if (vol->IsMountLocked()) { + // The volume is currently locked, so leave it in the mounted + // state. + LOGW("UpdateState: Mounted volume %s is locked, not sharing or formatting", + vol->NameStr()); + break; + } + + // Mark the volume as if we've started sharing/formatting/unmmounting. + // This will cause apps which watch device storage notifications to see + // the volume go into the different state, and prompt them to close any + // open files that they might have. + if (tryToShare && vol->IsSharingEnabled()) { + vol->SetIsSharing(true); + } else if (vol->IsFormatRequested()){ + vol->SetIsFormatting(true); + } else if (vol->IsUnmountRequested()){ + vol->SetIsUnmounting(true); + } + + // Check to see if there are any open files on the volume and + // don't initiate the unmount while there are open files. + OpenFileFinder::Info fileInfo; + OpenFileFinder fileFinder(vol->MountPoint()); + if (fileFinder.First(&fileInfo)) { + LOGW("The following files are open under '%s'", + vol->MountPoint().get()); + do { + LOGW(" PID: %d file: '%s' app: '%s' comm: '%s' exe: '%s'\n", + fileInfo.mPid, + fileInfo.mFileName.get(), + fileInfo.mAppName.get(), + fileInfo.mComm.get(), + fileInfo.mExe.get()); + } while (fileFinder.Next(&fileInfo)); + LOGW("UpdateState: Mounted volume %s has open files, not sharing or formatting", + vol->NameStr()); + + // Check again in a few seconds to see if the files are closed. + // Since we're trying to share the volume, this implies that we're + // plugged into the PC via USB and this in turn implies that the + // battery is charging, so we don't need to be too concerned about + // wasting battery here. + // + // If we just detected that there were files open, then we use + // a short timer. We will have told the apps that we're trying + // trying to share, and they'll be closing their files. This makes + // the sharing more responsive. If after a few seconds, the apps + // haven't closed their files, then we back off. + + int delay = 1000; + if (filesOpenDelayCount > 10) { + delay = 5000; + } + MessageLoopForIO::current()-> + PostDelayedTask(NewRunnableMethod(this, &AutoMounter::UpdateState), + delay); + filesOpen = true; + break; + } + + // Volume is mounted, we need to unmount before + // we can share. + LOG("UpdateState: Unmounting %s", vol->NameStr()); + vol->StartUnmount(mResponseCallback); + return; // UpdateState will be called again when the Unmount command completes + } + case nsIVolume::STATE_IDLE: + case nsIVolume::STATE_MOUNT_FAIL: { + LOG("UpdateState: Volume %s is %s", vol->NameStr(), vol->StateStr()); + if (vol->IsFormatting() && !vol->IsFormatRequested()) { + vol->SetFormatRequested(false); + if (!(tryToShare && vol->IsSharingEnabled()) && volState == nsIVolume::STATE_IDLE) { + LOG("UpdateState: Mounting %s", vol->NameStr()); + vol->StartMount(mResponseCallback); + break; + } + } + + // If there are format and share requests in the same time, + // we should do format first then share. + if (vol->IsFormatRequested()) { + // Volume is unmounted. We can go ahead and format. + LOG("UpdateState: Formatting %s", vol->NameStr()); + vol->StartFormat(mResponseCallback); + } else if (tryToShare && vol->IsSharingEnabled() && volState == nsIVolume::STATE_IDLE) { + // Volume is unmounted. We can go ahead and share. + LOG("UpdateState: Sharing %s", vol->NameStr()); + vol->StartShare(mResponseCallback); + } + return; // UpdateState will be called again when the Share/Format command completes + } + default: { + // Not in a state that we can do anything about. + break; + } + } + } else { + // We're going to try and unshare and remount the volumes + switch (volState) { + case nsIVolume::STATE_SHARED: { + // Volume is shared. We can go ahead and unshare. + LOG("UpdateState: Unsharing %s", vol->NameStr()); + vol->StartUnshare(mResponseCallback); + return; // UpdateState will be called again when the Unshare command completes + } + case nsIVolume::STATE_IDLE: { + if (!vol->IsUnmountRequested()) { + // Volume is unmounted and mount-requested, try to mount. + + LOG("UpdateState: Mounting %s", vol->NameStr()); + vol->StartMount(mResponseCallback); + } + return; // UpdateState will be called again when Mount command completes + } + default: { + // Not in a state that we can do anything about. + break; + } + } + } + } + + int32_t status = AUTOMOUNTER_STATUS_DISABLED; + if (filesOpen) { + filesOpenDelayCount++; + status = AUTOMOUNTER_STATUS_FILES_OPEN; + } else if (enabled) { + filesOpenDelayCount = 0; + status = AUTOMOUNTER_STATUS_ENABLED; + } + SetAutoMounterStatus(status); +} + +/***************************************************************************/ + +void AutoMounter::GetStatus(bool& umsAvail, bool& umsConfigured, bool& umsEnabled, + bool& mtpAvail, bool& mtpConfigured, bool& mtpEnabled, + bool& rndisConfigured) +{ + umsAvail = false; + umsConfigured = false; + umsEnabled = false; + mtpAvail = false; + mtpConfigured = false; + mtpEnabled = false; + rndisConfigured = false; + + if (access(ICS_SYS_USB_FUNCTIONS, F_OK) != 0) { + return; + } + + char functionsStr[60]; + if (!ReadSysFile(ICS_SYS_USB_FUNCTIONS, functionsStr, sizeof(functionsStr))) { + ERR("Error reading file '%s': %s", ICS_SYS_USB_FUNCTIONS, strerror(errno)); + functionsStr[0] = '\0'; + } + DBG("GetStatus: USB functions: '%s'", functionsStr); + + bool usbConfigured = IsUsbConfigured(); + + // On the Nexus 4/5, it advertises that the UMS usb function is available, + // but we have a further requirement that mass_storage be in the + // persist.sys.usb.config property. + char persistSysUsbConfig[PROPERTY_VALUE_MAX]; + property_get(PERSIST_SYS_USB_CONFIG, persistSysUsbConfig, ""); + if (IsUsbFunctionEnabled(persistSysUsbConfig, USB_FUNC_UMS)) { + umsAvail = (access(ICS_SYS_UMS_DIRECTORY, F_OK) == 0); + } + if (umsAvail) { + umsConfigured = usbConfigured && strstr(functionsStr, USB_FUNC_UMS) != nullptr; + umsEnabled = (mMode == AUTOMOUNTER_ENABLE_UMS) || + ((mMode == AUTOMOUNTER_DISABLE_WHEN_UNPLUGGED) && umsConfigured); + } else { + umsConfigured = false; + umsEnabled = false; + } + + mtpAvail = (access(ICS_SYS_MTP_DIRECTORY, F_OK) == 0); + if (mtpAvail) { + mtpConfigured = usbConfigured && strstr(functionsStr, USB_FUNC_MTP) != nullptr; + mtpEnabled = (mMode == AUTOMOUNTER_ENABLE_MTP) || + ((mMode == AUTOMOUNTER_DISABLE_WHEN_UNPLUGGED) && mtpConfigured); + } else { + mtpConfigured = false; + mtpEnabled = false; + } + + rndisConfigured = strstr(functionsStr, USB_FUNC_RNDIS) != nullptr; +} + + +nsresult AutoMounter::Dump(nsACString& desc) +{ + DBG("GetState!"); + bool umsAvail, umsConfigured, umsEnabled; + bool mtpAvail, mtpConfigured, mtpEnabled; + bool rndisConfigured; + GetStatus(umsAvail, umsConfigured, umsEnabled, mtpAvail, + mtpConfigured, mtpEnabled, rndisConfigured); + if (mMode == AUTOMOUNTER_DISABLE_WHEN_UNPLUGGED) { + // DISABLE_WHEN_UNPLUGGED implies already enabled. + if (!IsUsbCablePluggedIn()) { + mMode = AUTOMOUNTER_DISABLE; + mtpEnabled = false; + umsEnabled = false; + } + } + + // Automounter information + desc += "Current Mode:"; + desc += ModeStr(mMode); + desc += "|"; + + + desc += "Current State:"; + desc += StateStr(mState); + desc += "|"; + + desc += "UMS Status:"; + if (umsAvail) { + desc += "Available"; + } else { + desc += "UnAvailable"; + } + desc += ","; + if (umsConfigured) { + desc += "Configured"; + } else { + desc += "Un-Configured"; + } + desc += ","; + if (umsEnabled) { + desc += "Enabled"; + } else { + desc += "Disabled"; + } + desc += "|"; + + + desc += "MTP Status:"; + if (mtpAvail) { + desc += "Available"; + } else { + desc += "UnAvailable"; + } + desc += ","; + if (mtpConfigured) { + desc += "Configured"; + } else { + desc += "Un-Configured"; + } + desc += ","; + if (mtpEnabled) { + desc += "Enabled"; + } else { + desc += "Disabled"; + } + + + // Volume information + VolumeArray::index_type volIndex; + VolumeArray::size_type numVolumes = VolumeManager::NumVolumes(); + for (volIndex = 0; volIndex < numVolumes; volIndex++) { + RefPtr<Volume> vol = VolumeManager::GetVolume(volIndex); + + desc += "|"; + desc += vol->NameStr(); + desc += ":"; + desc += vol->StateStr(); + desc += "@"; + desc += vol->MountPoint().get(); + + if (!vol->MediaPresent()) { + continue; + } + + if (vol->CanBeShared()) { + desc += ",CanBeShared"; + } + if (vol->CanBeFormatted()) { + desc += ",CanBeFormatted"; + } + if (vol->CanBeMounted()) { + desc += ",CanBeMounted"; + } + if (vol->IsRemovable()) { + desc += ",Removable"; + } + if (vol->IsHotSwappable()) { + desc += ",HotSwappable"; + } + } + + return NS_OK; +} + + +static void +InitAutoMounterIOThread() +{ + MOZ_ASSERT(MessageLoop::current() == XRE_GetIOMessageLoop()); + MOZ_ASSERT(!sAutoMounter); + + sAutoMounter = new AutoMounter(); +} + +static void +ShutdownAutoMounterIOThread() +{ + MOZ_ASSERT(MessageLoop::current() == XRE_GetIOMessageLoop()); + + sAutoMounter = nullptr; + ShutdownVolumeManager(); +} + +static void +SetAutoMounterModeIOThread(const int32_t& aMode) +{ + MOZ_ASSERT(XRE_IsParentProcess()); + MOZ_ASSERT(MessageLoop::current() == XRE_GetIOMessageLoop()); + MOZ_ASSERT(sAutoMounter); + + sAutoMounter->SetMode(aMode); +} + +static void +SetAutoMounterSharingModeIOThread(const nsCString& aVolumeName, const bool& aAllowSharing) +{ + MOZ_ASSERT(XRE_IsParentProcess()); + MOZ_ASSERT(MessageLoop::current() == XRE_GetIOMessageLoop()); + MOZ_ASSERT(sAutoMounter); + + sAutoMounter->SetSharingMode(aVolumeName, aAllowSharing); +} + +static void +AutoMounterFormatVolumeIOThread(const nsCString& aVolumeName) +{ + MOZ_ASSERT(XRE_IsParentProcess()); + MOZ_ASSERT(MessageLoop::current() == XRE_GetIOMessageLoop()); + MOZ_ASSERT(sAutoMounter); + + sAutoMounter->FormatVolume(aVolumeName); +} + +static void +AutoMounterMountVolumeIOThread(const nsCString& aVolumeName) +{ + MOZ_ASSERT(XRE_IsParentProcess()); + MOZ_ASSERT(MessageLoop::current() == XRE_GetIOMessageLoop()); + MOZ_ASSERT(sAutoMounter); + + sAutoMounter->MountVolume(aVolumeName); +} + +static void +AutoMounterUnmountVolumeIOThread(const nsCString& aVolumeName) +{ + MOZ_ASSERT(XRE_IsParentProcess()); + MOZ_ASSERT(MessageLoop::current() == XRE_GetIOMessageLoop()); + MOZ_ASSERT(sAutoMounter); + + sAutoMounter->UnmountVolume(aVolumeName); +} + +static void +UsbCableEventIOThread() +{ + MOZ_ASSERT(MessageLoop::current() == XRE_GetIOMessageLoop()); + + if (!sAutoMounter) { + return; + } + DBG("Calling UpdateState due to USBCableEvent"); + sAutoMounter->UpdateState(); +} + +/************************************************************************** +* +* Public API +* +* Since the AutoMounter runs in IO Thread context, we need to switch +* to IOThread context before we can do anything. +* +**************************************************************************/ + +class UsbCableObserver final : public hal::SwitchObserver +{ + ~UsbCableObserver() + { + hal::UnregisterSwitchObserver(hal::SWITCH_USB, this); + } + +public: + NS_INLINE_DECL_REFCOUNTING(UsbCableObserver) + + UsbCableObserver() + { + hal::RegisterSwitchObserver(hal::SWITCH_USB, this); + } + + virtual void Notify(const hal::SwitchEvent& aEvent) + { + DBG("UsbCable switch device: %d state: %s\n", + aEvent.device(), SwitchStateStr(aEvent)); + XRE_GetIOMessageLoop()->PostTask( + NewRunnableFunction(UsbCableEventIOThread)); + } +}; + +static StaticRefPtr<UsbCableObserver> sUsbCableObserver; +static StaticRefPtr<AutoMounterSetting> sAutoMounterSetting; + +void +InitAutoMounter() +{ + InitVolumeManager(); + sAutoMounterSetting = new AutoMounterSetting(); + + XRE_GetIOMessageLoop()->PostTask( + NewRunnableFunction(InitAutoMounterIOThread)); + + // Switch Observers need to run on the main thread, so we need to + // start it here and have it send events to the AutoMounter running + // on the IO Thread. + sUsbCableObserver = new UsbCableObserver(); + + // Register status reporter into reporter manager + if(status_reporter_progress == REPORTER_UNREGISTERED) { + NS_RegisterStatusReporter(new NS_STATUS_REPORTER_NAME(AutoMounter)); + } + status_reporter_progress = REPORTER_REGISTERED; +} + +int32_t +GetAutoMounterStatus() +{ + if (sAutoMounterSetting) { + return sAutoMounterSetting->GetStatus(); + } + return AUTOMOUNTER_STATUS_DISABLED; +} + +//static +void +SetAutoMounterStatus(int32_t aStatus) +{ + if (sAutoMounterSetting) { + sAutoMounterSetting->SetStatus(aStatus); + } +} + +void +SetAutoMounterMode(int32_t aMode) +{ + XRE_GetIOMessageLoop()->PostTask( + NewRunnableFunction(SetAutoMounterModeIOThread, aMode)); +} + +void +SetAutoMounterSharingMode(const nsCString& aVolumeName, bool aAllowSharing) +{ + XRE_GetIOMessageLoop()->PostTask( + NewRunnableFunction(SetAutoMounterSharingModeIOThread, + aVolumeName, aAllowSharing)); +} + +void +AutoMounterFormatVolume(const nsCString& aVolumeName) +{ + XRE_GetIOMessageLoop()->PostTask( + NewRunnableFunction(AutoMounterFormatVolumeIOThread, + aVolumeName)); +} + +void +AutoMounterMountVolume(const nsCString& aVolumeName) +{ + XRE_GetIOMessageLoop()->PostTask( + NewRunnableFunction(AutoMounterMountVolumeIOThread, + aVolumeName)); +} + +void +AutoMounterUnmountVolume(const nsCString& aVolumeName) +{ + XRE_GetIOMessageLoop()->PostTask( + NewRunnableFunction(AutoMounterUnmountVolumeIOThread, + aVolumeName)); +} + +void +ShutdownAutoMounter() +{ + if (sAutoMounter) { + DBG("ShutdownAutoMounter: About to StopMtpServer"); + sAutoMounter->StopMtpServer(); + // Unregister status reporter into reporter manager + if(status_reporter_progress == REPORTER_REGISTERED) { + NS_UnregisterStatusReporter(new NS_STATUS_REPORTER_NAME(AutoMounter)); + } + status_reporter_progress = REPORTER_UNREGISTERED; + } + sAutoMounterSetting = nullptr; + sUsbCableObserver = nullptr; + + XRE_GetIOMessageLoop()->PostTask( + NewRunnableFunction(ShutdownAutoMounterIOThread)); +} + +} // system +} // mozilla |