- Add missing extra-armv6_hal patch

1 files changed, 1463 insertions, 0 deletions

diff --git a/multimedia/kodi/files/extra-armv6_hal b/multimedia/kodi/files/extra-armv6_hal
new file mode 100644
index 000000000000..b65dbf109129
--- /dev/null
+++ b/multimedia/kodi/files/extra-armv6_hal
@@ -0,0 +1,1463 @@
+--- addons/resource.language.en_gb/resources/strings.po.orig 2016-11-12 UTC
++++ addons/resource.language.en_gb/resources/strings.po
+@@ -5652,17 +5652,17 @@ msgctxt "#13020"
+ msgid "Is another session active, perhaps over ssh?"
+ msgstr ""
+
+-#: xbmc/storage/MediaManager.cpp
++#: xbmc/linux/HALManager.cpp
+ msgctxt "#13021"
+ msgid "Mounted removable storage device"
+ msgstr ""
+
+-#: xbmc/storage/MediaManager.cpp
++#: xbmc/linux/HALManager.cpp
+ msgctxt "#13022"
+ msgid "Unsafe storage device removal"
+ msgstr ""
+
+-#: xbmc/storage/MediaManager.cpp
++#: xbmc/linux/HALManager.cpp
+ msgctxt "#13023"
+ msgid "Successfully removed storage device"
+ msgstr ""
+--- configure.ac.orig	2016-04-24 UTC
++++ configure.ac
+@@ -175,6 +175,9 @@ dbus_disabled="== DBUS support disabled.
+ x11_enabled="== X11 enabled. =="
+ x11_disabled="== X11 disabled. =="
+ pulse_not_found="== Could not find libpulse. PulseAudio support disabled. =="
++hal_not_found="== Could not find hal. HAL support disabled. =="
++halstorage_not_found="== Could not find hal-storage. HAL support disabled. =="
++hal_disabled="== HAL support disabled. =="
+ pulse_disabled="== PulseAudio support disabled. =="
+ avahi_not_found="== Could not find libavahi-common or libavahi-client. Avahi support disabled. =="
+ avahi_disabled="== Avahi support disabled. =="
+@@ -358,6 +361,12 @@ AC_ARG_ENABLE([mid],
+   [use_mid=$enableval],
+   [use_mid=no])
+ 
++AC_ARG_ENABLE([hal],
++  [AS_HELP_STRING([--disable-hal],
++  [disable HAL support (default is enabled if hal and hal-storage is found)])],
++  [use_hal=$enableval],
++  [use_hal=yes])
++
+ AC_ARG_ENABLE([avahi],
+   [AS_HELP_STRING([--disable-avahi],
+   [disable Avahi support (default is enabled if libavahi-common and libavahi-client is found)])],
+@@ -1249,6 +1258,26 @@ else
+   USE_PULSE=0
+ fi
+ 
++# HAL
++if test "$host_vendor" = "apple" ; then
++  use_hal="no"
++  AC_MSG_RESULT($hal_disabled)
++else
++  if test "$use_hal" = "yes"; then
++    PKG_CHECK_MODULES([HAL], [hal],
++      [INCLUDES="$INCLUDES $HAL_CFLAGS"; LIBS="$LIBS $HAL_LIBS"],
++      use_hal=no;AC_MSG_RESULT($hal_not_found))
++    PKG_CHECK_MODULES([HAL_STORAGE], [hal-storage],
++      [INCLUDES="$INCLUDES $HAL_STORAGE_CFLAGS"; LIBS="$LIBS $HAL_STORAGE_LIBS"],
++      use_hal=no;AC_MSG_RESULT($halstorage_not_found))
++  else
++    AC_MSG_RESULT($hal_disabled)
++  fi
++  if test "$use_hal" = "yes"; then
++    AC_DEFINE([HAS_HAL], [1], [Define to 1 if you have HAL installed])
++  fi
++fi
++
+ # avahi
+ if test "$use_avahi" = "yes"; then
+   AC_CHECK_LIB([avahi-common], [main],,
+@@ -1984,6 +2013,12 @@ else
+   final_message="$final_message\n  PulseAudio:\tNo"
+ fi
+ 
++if test "$use_hal" = "yes"; then
++  final_message="$final_message\n  HAL Support:\tYes"
++else
++  final_message="$final_message\n  HAL Support:\tNo"
++fi
++
+ # Google Test Framework
+ if test "$configure_gtest" = "yes"; then
+   AC_MSG_NOTICE($gtest_enabled)
+--- xbmc/Application.cpp.orig	2016-09-03 UTC
++++ xbmc/Application.cpp
+@@ -194,6 +194,10 @@
+ #include <cdio/logging.h>
+ #endif
+ 
++#ifdef HAS_HAL
++#include "linux/HALManager.h"
++#endif
++
+ #include "storage/MediaManager.h"
+ #include "utils/JobManager.h"
+ #include "utils/SaveFileStateJob.h"
+--- xbmc/linux/HALManager.cpp.orig	2016-09-06 UTC
++++ xbmc/linux/HALManager.cpp
+@@ -0,0 +1,759 @@
++/*
++ *      Copyright (C) 2005-2013 Team XBMC
++ *      http://xbmc.org
++ *
++ *  This Program is free software; you can redistribute it and/or modify
++ *  it under the terms of the GNU General Public License as published by
++ *  the Free Software Foundation; either version 2, or (at your option)
++ *  any later version.
++ *
++ *  This Program is distributed in the hope that it will be useful,
++ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ *  GNU General Public License for more details.
++ *
++ *  You should have received a copy of the GNU General Public License
++ *  along with XBMC; see the file COPYING.  If not, see
++ *  <http://www.gnu.org/licenses/>.
++ *
++ */
++
++#include "system.h"
++#ifdef HAS_HAL
++#include "HALManager.h"
++#include "interfaces/builtins/Builtins.h"
++#include <libhal-storage.h>
++#include "threads/SingleLock.h"
++#include "utils/URIUtils.h"
++#include "guilib/LocalizeStrings.h"
++#include "powermanagement/PowerManager.h"
++#include "settings/AdvancedSettings.h"
++#include "dialogs/GUIDialogKaiToast.h"
++
++#ifdef HAS_SDL_JOYSTICK
++#include <SDL/SDL.h>
++#include <SDL/SDL_version.h>
++#include "input/SDLJoystick.h"
++#endif
++
++bool CHALManager::NewMessage;
++DBusError CHALManager::m_Error;
++CCriticalSection CHALManager::m_lock;
++
++/* A Removed device, It isn't possible to make a LibHalVolume from a removed device therefor
++   we catch the UUID from the udi on the removal */
++void CHALManager::DeviceRemoved(LibHalContext *ctx, const char *udi)
++{
++  NewMessage = true;
++  CLog::Log(LOGDEBUG, "HAL: Device (%s) Removed", udi);
++  g_HalManager.RemoveDevice(udi);
++}
++
++void CHALManager::DeviceNewCapability(LibHalContext *ctx, const char *udi, const char *capability)
++{
++  NewMessage = true;
++  CLog::Log(LOGDEBUG, "HAL: Device (%s) gained capability %s", udi, capability);
++  g_HalManager.UpdateDevice(udi);
++}
++
++void CHALManager::DeviceLostCapability(LibHalContext *ctx, const char *udi, const char *capability)
++{
++  NewMessage = true;
++  CLog::Log(LOGDEBUG, "HAL: Device (%s) lost capability %s", udi, capability);
++  g_HalManager.UpdateDevice(udi);
++}
++
++/* HAL Property modified callback. If a device is mounted. This is called. */
++void CHALManager::DevicePropertyModified(LibHalContext *ctx, const char *udi, const char *key, dbus_bool_t is_removed, dbus_bool_t is_added)
++{
++  NewMessage = true;
++  CLog::Log(LOGDEBUG, "HAL: Device (%s) Property %s modified", udi, key);
++  g_HalManager.UpdateDevice(udi);
++}
++
++void CHALManager::DeviceCondition(LibHalContext *ctx, const char *udi, const char *condition_name, const char *condition_details)
++{
++  NewMessage = true;
++  CLog::Log(LOGDEBUG, "HAL: Device (%s) Condition %s | %s", udi, condition_name, condition_details);
++  if (!strcmp(condition_name, "ButtonPressed") && !strcmp(condition_details, "power"))
++    CBuiltins::GetInstance().Execute("XBMC.ShutDown()");
++  else
++    g_HalManager.UpdateDevice(udi);
++}
++
++/* HAL Device added. This is before mount. And here is the place to mount the volume in the future */
++void CHALManager::DeviceAdded(LibHalContext *ctx, const char *udi)
++{
++  NewMessage = true;
++  CLog::Log(LOGDEBUG, "HAL: Device (%s) Added", udi);
++  g_HalManager.AddDevice(udi);
++}
++
++CHALManager g_HalManager;
++
++/* Iterate through all devices currently on the computer. Needed mostly at startup */
++void CHALManager::GenerateGDL()
++{
++  if (m_Context == NULL)
++    return;
++
++  char **GDL;
++  int i = 0;
++  CLog::Log(LOGDEBUG, "HAL: Clearing old global device list, if any");
++  m_Volumes.clear();
++
++  CLog::Log(LOGNOTICE, "HAL: Generating global device list");
++  GDL = libhal_get_all_devices(g_HalManager.m_Context, &i, &m_Error);
++
++  for (i = 0; GDL[i]; i++)
++  {
++    AddDevice(GDL[i]);
++  }
++  CLog::Log(LOGINFO, "HAL: Generated global device list, found %i", i);
++
++  libhal_free_string_array(GDL);
++}
++
++// Return all volumes that currently are available (Mostly needed at startup, the rest of the volumes comes as events.)
++std::vector<CStorageDevice> CHALManager::GetVolumeDevices()
++{
++  CSingleLock lock(m_lock);
++  return m_Volumes;
++}
++
++CHALManager::CHALManager()
++{
++  m_Notifications = false;
++  m_Context = NULL;
++  m_DBusSystemConnection = NULL;
++#if defined(HAS_SDL_JOYSTICK)
++  const SDL_version *sdl_version = SDL_Linked_Version();
++  m_bMultipleJoysticksSupport = (sdl_version->major >= 1 && sdl_version->minor >= 3)?true:false;
++#endif
++}
++
++void CHALManager::Stop()
++{
++  if (g_advancedSettings.m_handleMounting)
++  { // Unmount all media XBMC have mounted
++    for (unsigned int i = 0; i < m_Volumes.size(); i++)
++    {
++      if (m_Volumes[i].MountedByXBMC && m_Volumes[i].Mounted)
++      {
++        CLog::Log(LOGNOTICE, "HAL: Unmounts %s", m_Volumes[i].FriendlyName.c_str());
++        UnMount(m_Volumes[i]);
++      }
++    }
++  }
++
++  m_Volumes.clear();
++
++  if (m_Context != NULL)
++    libhal_ctx_shutdown(m_Context, NULL);
++  if (m_Context != NULL)
++    libhal_ctx_free(m_Context);
++
++  if (m_DBusSystemConnection != NULL)
++  {
++    dbus_connection_unref(m_DBusSystemConnection);
++    m_DBusSystemConnection = NULL;
++  }
++  dbus_error_free(&m_Error); // Needed?
++}
++
++// Initialize
++void CHALManager::Initialize()
++{
++  m_Notifications = false;
++  CLog::Log(LOGINFO, "HAL: Starting initializing");
++  g_HalManager.m_Context = g_HalManager.InitializeHal();
++  if (g_HalManager.m_Context == NULL)
++  {
++    CLog::Log(LOGERROR, "HAL: no Hal context");
++    return;
++  }
++
++  GenerateGDL();
++
++  CLog::Log(LOGINFO, "HAL: Successfully initialized");
++  m_Notifications = true;
++}
++
++// Initialize basic DBus connection
++bool CHALManager::InitializeDBus()
++{
++  if (m_DBusSystemConnection != NULL)
++    return true;
++
++  dbus_error_init (&m_Error);
++  if (m_DBusSystemConnection == NULL && !(m_DBusSystemConnection = dbus_bus_get (DBUS_BUS_SYSTEM, &m_Error)))
++  {
++    CLog::Log(LOGERROR, "DBus: Could not get system bus: %s", m_Error.message);
++    dbus_error_free (&m_Error);
++  }
++
++  if (m_DBusSystemConnection != NULL)
++    return true;
++  else
++    return false;
++}
++
++// Initialize basic HAL connection
++LibHalContext *CHALManager::InitializeHal()
++{
++  LibHalContext *ctx;
++  char **devices;
++  int nr;
++
++  if (!InitializeDBus())
++    return NULL;
++
++  if (!(ctx = libhal_ctx_new()))
++  {
++    CLog::Log(LOGERROR, "HAL: failed to create a HAL context!");
++    return NULL;
++  }
++
++  if (!libhal_ctx_set_dbus_connection(ctx, m_DBusSystemConnection))
++    CLog::Log(LOGERROR, "HAL: Failed to connect with dbus");
++
++  libhal_ctx_set_device_added(ctx, DeviceAdded);
++  libhal_ctx_set_device_removed(ctx, DeviceRemoved);
++  libhal_ctx_set_device_new_capability(ctx, DeviceNewCapability);
++  libhal_ctx_set_device_lost_capability(ctx, DeviceLostCapability);
++  libhal_ctx_set_device_property_modified(ctx, DevicePropertyModified);
++  libhal_ctx_set_device_condition(ctx, DeviceCondition);
++
++  if (!libhal_device_property_watch_all(ctx, &m_Error))
++  {
++    CLog::Log(LOGERROR, "HAL: Failed to set property watch %s", m_Error.message);
++    dbus_error_free(&m_Error);
++    libhal_ctx_free(ctx);
++    return NULL;
++  }
++
++  if (!libhal_ctx_init(ctx, &m_Error))
++  {
++    CLog::Log(LOGERROR, "HAL: Failed to initialize hal context: %s", m_Error.message);
++    dbus_error_free(&m_Error);
++    libhal_ctx_free(ctx);
++    return NULL;
++  }
++
++  /*
++ * Do something to ping the HAL daemon - the above functions will
++ * succeed even if hald is not running, so long as DBUS is.  But we
++ * want to exit silently if hald is not running, to behave on
++ * pre-2.6 systems.
++ */
++  if (!(devices = libhal_get_all_devices(ctx, &nr, &m_Error)))
++  {
++    CLog::Log(LOGERROR, "HAL: seems that Hal daemon is not running: %s", m_Error.message);
++    dbus_error_free(&m_Error);
++
++    libhal_ctx_shutdown(ctx, NULL);
++    libhal_ctx_free(ctx);
++    return NULL;
++  }
++
++  libhal_free_string_array(devices);
++
++  return ctx;
++}
++
++// Helper function. creates a CStorageDevice from a HAL udi
++bool CHALManager::DeviceFromVolumeUdi(const char *udi, CStorageDevice *device)
++{
++  if (g_HalManager.m_Context == NULL)
++    return false;
++
++  LibHalVolume *tempVolume;
++  LibHalDrive  *tempDrive;
++  bool Created = false;
++
++  tempVolume = libhal_volume_from_udi(g_HalManager.m_Context, udi);
++  if (tempVolume)
++  {
++    const char *DriveUdi = libhal_volume_get_storage_device_udi(tempVolume);
++    tempDrive = libhal_drive_from_udi(g_HalManager.m_Context, DriveUdi);
++
++    if (tempDrive)
++    {
++      char * FriendlyName   = libhal_device_get_property_string(g_HalManager.m_Context, udi, "info.product", NULL);
++      device->FriendlyName  = FriendlyName;
++      libhal_free_string(FriendlyName);
++      char *block = libhal_device_get_property_string(g_HalManager.m_Context, udi, "block.device", NULL);
++      device->DevID         = block;
++      libhal_free_string(block);
++
++      device->HotPlugged  = (bool)libhal_drive_is_hotpluggable(tempDrive);
++      device->Type        = libhal_drive_get_type(tempDrive);
++      device->Mounted     = (bool)libhal_volume_is_mounted(tempVolume);
++      if (libhal_volume_get_mount_point(tempVolume) != NULL)
++          device->MountPoint  = libhal_volume_get_mount_point(tempVolume);
++      if (device->Mounted)
++        URIUtils::AddSlashAtEnd(device->MountPoint);
++      if (libhal_volume_get_label(tempVolume) != NULL)
++          device->Label       = libhal_volume_get_label(tempVolume);
++      if (libhal_volume_get_uuid(tempVolume) != NULL)
++          device->UUID        = libhal_volume_get_uuid(tempVolume);
++      if (libhal_volume_get_fstype(tempVolume) != NULL)
++          device->FileSystem  = libhal_volume_get_fstype(tempVolume);
++      device->HalIgnore   = libhal_device_get_property_bool(g_HalManager.m_Context, udi, "volume.ignore", NULL);
++      ApproveDevice(device);
++
++      libhal_drive_free(tempDrive);
++      Created = true;
++    }
++    else
++      CLog::Log(LOGERROR, "HAL: Couldn't create a Drive even if we had a volume - %s", udi);
++
++    libhal_volume_free(tempVolume);
++  }
++
++  return Created;
++}
++
++// Called from ProcessSlow to trigger the callbacks from DBus
++bool CHALManager::Update()
++{
++  CSingleLock lock(m_lock);
++  if (m_Context == NULL)
++    return false;
++
++  if (!dbus_connection_read_write_dispatch(m_DBusSystemConnection, 0)) // We choose 0 that means we won't wait for a message
++  {
++    CLog::Log(LOGERROR, "DBus: System - read/write dispatch");
++    return false;
++  }
++  if (NewMessage)
++  {
++    NewMessage = false;
++    return true;
++  }
++  else
++    return false;
++}
++
++/* libhal-storage type to readable form */
++const char *CHALManager::StorageTypeToString(int DeviceType)
++{
++  switch (DeviceType)
++  {
++  case 0:  return "removable disk";
++  case 1:  return "disk";
++  case 2:  return "cdrom";
++  case 3:  return "floppy";
++  case 4:  return "tape";
++  case 5:  return "compact flash";
++  case 6:  return "memory stick";
++  case 7:  return "smart media";
++  case 8:  return "sd mmc";
++  case 9:  return "camera";
++  case 10: return "audio player";
++  case 11: return "zip";
++  case 12: return "jaz";
++  case 13: return "flashkey";
++  case 14: return "magneto-optical";
++  default: return NULL;
++  }
++}
++
++/* Readable libhal-storage type to int type */
++int CHALManager::StorageTypeFromString(const char *DeviceString)
++{
++  if      (strcmp(DeviceString, "removable disk") == 0)  return 0;
++  else if (strcmp(DeviceString, "disk") == 0)            return 1;
++  else if (strcmp(DeviceString, "cdrom") == 0)           return 2;
++  else if (strcmp(DeviceString, "floppy") == 0)          return 3;
++  else if (strcmp(DeviceString, "tape") == 0)            return 4;
++  else if (strcmp(DeviceString, "compact flash") == 0)   return 5;
++  else if (strcmp(DeviceString, "memory stick") == 0)    return 6;
++  else if (strcmp(DeviceString, "smart media") == 0)     return 7;
++  else if (strcmp(DeviceString, "sd mmc") == 0)          return 8;
++  else if (strcmp(DeviceString, "camera") == 0)          return 9;
++  else if (strcmp(DeviceString, "audio player") == 0)    return 10;
++  else if (strcmp(DeviceString, "zip") == 0)             return 11;
++  else if (strcmp(DeviceString, "jaz") == 0)             return 12;
++  else if (strcmp(DeviceString, "flashkey") == 0)        return 13;
++  else if (strcmp(DeviceString, "magneto-optical") == 0) return 14;
++  return -1;
++}
++
++void CHALManager::UpdateDevice(const char *udi)
++{
++  CSingleLock lock(m_lock);
++  char *category;
++  category = libhal_device_get_property_string(m_Context, udi, "info.category", NULL);
++  if (category == NULL)
++    return;
++
++  if (strcmp(category, "volume") == 0)
++  {
++    CStorageDevice dev(udi);
++    if (!DeviceFromVolumeUdi(udi, &dev))
++      return;
++    for (unsigned int i = 0; i < m_Volumes.size(); i++)
++    {
++      if (strcmp(m_Volumes[i].UDI.c_str(), udi) == 0)
++      {
++        CLog::Log(LOGDEBUG, "HAL: Update - %s | %s", CHALManager::StorageTypeToString(dev.Type),  dev.toString().c_str());
++        if (g_advancedSettings.m_handleMounting)  // If the device was mounted by XBMC before it's still mounted by XBMC.
++            dev.MountedByXBMC = m_Volumes[i].MountedByXBMC;
++        if (!dev.Mounted && m_Volumes[i].Mounted)
++          CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Info, g_localizeStrings.Get(13023), dev.FriendlyName.c_str(), TOAST_DISPLAY_TIME, false);
++        m_Volumes[i] = dev;
++
++        break;
++      }
++    }
++  }
++
++  libhal_free_string(category);
++}
++void CHALManager::HandleNewVolume(CStorageDevice *dev)
++{
++  if (g_advancedSettings.m_handleMounting)
++  {
++/* Here it can be checked if the device isn't mounted and then mount */
++//TODO Have mountpoints be other than in /media/*
++    if (!dev->Mounted && (dev->HotPlugged || dev->Type == 2) && dev->Approved)
++    {
++      char **capability;
++      capability =libhal_device_get_property_strlist (m_Context, dev->UDI.c_str(), "info.capabilities", NULL);
++
++      bool Mountable = false;
++      if (dev->Type == 2 && (strcmp(capability[0], "volume.disc") == 0 && strcmp(capability[1], "volume") == 0)) // CD/DVD
++        Mountable = true;
++      else if ((strcmp(capability[0], "block") == 0 && strcmp(capability[1], "volume") == 0)) // HDD
++        Mountable = true;
++
++      if (Mountable)
++      {
++        CLog::Log(LOGNOTICE, "HAL: Trying to mount %s", dev->FriendlyName.c_str());
++        std::string MountPoint;
++        std::string TestPath;
++        if (dev->Label.size() > 0)
++        {
++          MountPoint = dev->Label.c_str();
++          TestPath = StringUtils::Format("/media/%s", MountPoint.c_str());
++          struct stat St;
++          if (stat("/media", &St) != 0)
++            return; //If /media doesn't exist something is wrong.
++          while(stat (TestPath.c_str(), &St) == 0 && S_ISDIR (St.st_mode))
++          {
++            CLog::Log(LOGDEBUG, "HAL: Proposed Mountpoint already existed");
++            MountPoint.append("_");
++            TestPath = StringUtils::Format("/media/%s", MountPoint.c_str());
++          }
++        }
++        else
++        {
++          MountPoint = StorageTypeToString(dev->Type);
++          TestPath = StringUtils::Format("/media/%s", MountPoint.c_str());
++          int Nbr = 0;
++          struct stat St;
++          if (stat("/media", &St) != 0)
++            return; //If /media doesn't exist something is wrong.
++          while(stat (TestPath.c_str(), &St) == 0 && S_ISDIR (St.st_mode))
++          {
++            CLog::Log(LOGDEBUG, "HAL: Proposed Mountpoint already existed");
++            Nbr++;
++            MountPoint = StringUtils::Format("%s%i", StorageTypeToString(dev->Type), Nbr);
++            TestPath = StringUtils::Format("/media/%s", MountPoint.c_str());
++          }
++        }
++        if (Mount(dev, MountPoint))
++        {
++          CLog::Log(LOGINFO, "HAL: mounted %s on %s", dev->FriendlyName.c_str(), dev->MountPoint.c_str());
++          if (m_Notifications)
++            CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Info, g_localizeStrings.Get(13021), dev->FriendlyName.c_str(), TOAST_DISPLAY_TIME, false);
++        }
++      }
++      libhal_free_string_array(capability);
++    }
++  }
++}
++
++/* Parse newly found device and add it to our remembered devices */
++void CHALManager::AddDevice(const char *udi)
++{
++  CSingleLock lock(m_lock);
++  char *category;
++  category = libhal_device_get_property_string(m_Context, udi, "info.category", NULL);
++  if (category == NULL)
++    return;
++
++  if (strcmp(category, "volume") == 0)
++  {
++    CStorageDevice dev(udi);
++    if (DeviceFromVolumeUdi(udi, &dev))
++    {
++      CLog::Log(LOGDEBUG, "HAL: Added - %s | %s", CHALManager::StorageTypeToString(dev.Type),  dev.toString().c_str());
++      HandleNewVolume(&dev);
++      m_Volumes.push_back(dev);
++    }
++  }
++#if defined(HAS_SDL_JOYSTICK)
++  // Scan input devices
++  else if (strcmp(category, "input") == 0)
++  {
++    DBusError dbusError;
++    dbus_error_init(&dbusError);
++
++    char **capability;
++    capability =libhal_device_get_property_strlist (m_Context, udi, "info.capabilities", &dbusError);
++    for(char **ptr = capability; *ptr != NULL;ptr++)
++    {
++      // Reload joysticks
++      if(strcmp(*ptr, "input.joystick") == 0)
++      {
++        CLog::Log(LOGINFO, "HAL: Joystick plugged in");
++        CHALDevice dev = CHALDevice(udi);
++        dev.FriendlyName = libhal_device_get_property_string(m_Context, udi, "info.product", &m_Error);
++        m_Joysticks.push_back(dev);
++
++        if(m_Joysticks.size() < 2 || m_bMultipleJoysticksSupport)
++        {
++          // Restart SDL joystick subsystem
++          if (!g_Joystick.Reinitialize())
++            break;
++
++          if (m_Notifications)
++            CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Info, g_localizeStrings.Get(13024), dev.FriendlyName.c_str(), TOAST_DISPLAY_TIME, false);
++        }
++      }
++    }
++    libhal_free_string_array(capability);
++  }
++#endif
++/*
++  else if (strcmp(category, "camera") == 0)
++  { // PTP-Devices }
++  else if (strcmp(category, "bluetooth_hci") == 0)
++  { // Bluetooth-Devices }
++  else if (strcmp(category, "portable audio player") == 0)
++  { // MTP-Devices }
++  else if (strcmp(category, "alsa") == 0)
++  { //Alsa Devices }
++*/
++
++  libhal_free_string(category);
++}
++
++/* Here we should iterate through our remembered devices if any of them are removed */
++bool CHALManager::RemoveDevice(const char *udi)
++{
++  CSingleLock lock(m_lock);
++  for (unsigned int i = 0; i < m_Volumes.size(); i++)
++  {
++    if (strcmp(m_Volumes[i].UDI.c_str(), udi) == 0)
++    {
++      CLog::Log(LOGNOTICE, "HAL: Removed - %s | %s", CHALManager::StorageTypeToString(m_Volumes[i].Type), m_Volumes[i].toString().c_str());
++
++      if (m_Volumes[i].Mounted)
++      {
++        if (g_advancedSettings.m_handleMounting)
++          UnMount(m_Volumes[i]);
++        if (m_Notifications)
++          CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Warning, g_localizeStrings.Get(13022), m_Volumes[i].FriendlyName.c_str());
++        CLog::Log(LOGNOTICE, "HAL: Unsafe drive removal");
++      }
++      m_Volumes.erase(m_Volumes.begin() + i);
++      return true;
++    }
++  }
++#if defined(HAS_SDL_JOYSTICK)
++  for(uint i = 0; i < m_Joysticks.size(); i++)
++  {
++    if (strcmp(m_Joysticks[i].UDI.c_str(), udi) == 0)
++    {
++      if(m_Joysticks.size() < 3 || m_bMultipleJoysticksSupport)
++      {
++        // Restart SDL joystick subsystem
++        if (!g_Joystick.Reinitialize())
++          return false;
++
++        if (m_Notifications)
++          CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Warning, g_localizeStrings.Get(13025), m_Joysticks[i].FriendlyName.c_str(), TOAST_DISPLAY_TIME, false);
++      }
++      m_Joysticks.erase(m_Joysticks.begin() + i);
++      return true;
++    }
++  }
++#endif
++  return false;
++}
++
++bool CHALManager::ApproveDevice(CStorageDevice *device)
++{
++  bool approve = true;
++  //This is only because it's easier to read...
++  const char *fs = device->FileSystem.c_str();
++
++  if ( strcmp(fs, "vfat") == 0    || strcmp(fs, "ext2") == 0
++       || strcmp(fs, "ext3") == 0 || strcmp(fs, "reiserfs") == 0
++       || strcmp(fs, "ntfs") == 0 || strcmp(fs, "ntfs-3g") == 0
++       || strcmp(fs, "udf") == 0  || strcmp(fs, "iso9660") == 0
++       || strcmp(fs, "xfs") == 0  || strcmp(fs, "hfsplus") == 0
++       || strcmp(fs, "ext4") == 0 || strcmp(fs, "ufs") == 0)
++    approve = true;
++  else
++    approve = false;
++
++  // Ignore some mountpoints, unless a weird setup these should never contain anything usefull for an enduser.
++  if (strcmp(device->MountPoint.c_str(), "/") == 0 || strcmp(device->MountPoint.c_str(), "/boot/") == 0 || strcmp(device->MountPoint.c_str(), "/mnt/") == 0 || strcmp(device->MountPoint.c_str(), "/home/") == 0)
++    approve = false;
++
++  if (device->HalIgnore)
++    approve = false;
++
++  device->Approved = approve;
++  return approve;
++}
++
++bool CHALManager::Eject(const std::string& path)
++{
++  for (unsigned int i = 0; i < m_Volumes.size(); i++)
++  {
++    if (m_Volumes[i].MountPoint == path)
++      return m_Volumes[i].HotPlugged ? UnMount(m_Volumes[i]) : false;
++  }
++
++  return false;
++}
++
++bool CHALManager::UnMount(CStorageDevice volume)
++{
++  CLog::Log(LOGNOTICE, "HAL: UnMounting %s (%s)", volume.UDI.c_str(), volume.toString().c_str());
++  DBusMessage* msg;
++  DBusMessageIter args;
++  DBusError error;
++  dbus_error_init (&error);
++  DBusConnection *connection = dbus_bus_get (DBUS_BUS_SYSTEM, &error);
++  if (connection)
++  {
++    msg = dbus_message_new_method_call("org.freedesktop.Hal", volume.UDI.c_str(), "org.freedesktop.Hal.Device.Volume", "Unmount");
++    dbus_message_iter_init_append(msg, &args);
++    DBusMessageIter sub;
++    dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &sub);
++    const char *s = "lazy";
++    dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &s);
++    dbus_message_iter_close_container(&args, &sub);
++
++    if (msg == NULL)
++        CLog::Log(LOGERROR, "DBus: Create UnMount Message failed");
++    else
++    {
++      DBusMessage *reply;
++      reply = dbus_connection_send_with_reply_and_block(connection, msg, -1, &error); //The reply timout might be bad to have as -1
++      if (dbus_error_is_set(&error))
++      {
++        CLog::Log(LOGERROR, "DBus: %s - %s", error.name, error.message);
++        dbus_error_free(&error);
++        return false;
++      }
++      // Need to create a reader for the Message
++      dbus_message_unref (reply);
++      dbus_message_unref(msg);
++      msg = NULL;
++    }
++
++    volume.MountPoint = "";
++    volume.Mounted    = false;
++    dbus_connection_unref(connection);
++    connection = NULL;
++    return true;
++  }
++  else
++  {
++    CLog::Log(LOGERROR, "DBus: Failed to connect to Systembus");
++    dbus_error_free(&error);
++    return false;
++  }
++}
++
++bool CHALManager::Mount(CStorageDevice *volume, const std::string &mountpath)
++{
++  CLog::Log(LOGNOTICE, "HAL: Mounting %s (%s) at %s with umask=%u", volume->UDI.c_str(), volume->toString().c_str(), mountpath.c_str(), umask (0));
++  DBusMessage* msg;
++  DBusMessageIter args;
++  DBusError error;
++  dbus_error_init (&error);
++  DBusConnection *connection = dbus_bus_get (DBUS_BUS_SYSTEM, &error);
++  const char *s;
++  if (connection)
++  {
++    msg = dbus_message_new_method_call("org.freedesktop.Hal", volume->UDI.c_str(), "org.freedesktop.Hal.Device.Volume", "Mount");
++    dbus_message_iter_init_append(msg, &args);
++    s = mountpath.c_str();
++    if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &s))
++      CLog::Log(LOGERROR, "DBus: Failed to append arguments");
++    s = ""; //FileSystem
++    if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &s))
++      CLog::Log(LOGERROR, "DBus: Failed to append arguments");
++    DBusMessageIter sub;
++    dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &sub);
++
++    std::string temporaryString;
++
++#if defined(__linux__)
++    if (volume->FileSystem == "vfat")
++    {
++      int mask = umask (0);
++      temporaryString = StringUtils::Format("umask=%#o", mask);
++      s = temporaryString.c_str();
++      dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &s);
++      temporaryString = StringUtils::Format("uid=%u", getuid());
++      s = temporaryString.c_str();
++      dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &s);
++      s = "shortname=mixed";
++      dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &s);
++      s = "utf8";
++      dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &s);
++      // 'sync' option will slow down transfer speed significantly for FAT filesystems. We prefer 'flush' instead.
++      s = "flush";
++      dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &s);
++    }
++    else
++    {
++      s = "sync";
++      dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &s);
++    }
++#endif
++
++    dbus_message_iter_close_container(&args, &sub);
++
++    if (msg == NULL)
++        CLog::Log(LOGERROR, "DBus: Create Mount Message failed");
++    else
++    {
++      DBusMessage *reply;
++      reply = dbus_connection_send_with_reply_and_block(connection, msg, -1, &error); //The reply timout might be bad to have as -1
++      if (dbus_error_is_set(&error))
++      {
++        CLog::Log(LOGERROR, "DBus: %s - %s", error.name, error.message);
++        dbus_error_free(&error);
++        return false;
++      }
++      // Need to create a reader for the Message
++      dbus_message_unref (reply);
++      dbus_message_unref(msg);
++      msg = NULL;
++    }
++
++    volume->Mounted = true;
++    volume->MountedByXBMC = true;
++    volume->MountPoint = mountpath;
++    dbus_connection_unref(connection);
++    connection = NULL;
++    return true;
++  }
++  else
++  {
++    CLog::Log(LOGERROR, "DBus: Failed to connect to Systembus");
++    dbus_error_free(&error);
++    return false;
++  }
++}
++#endif // HAS_HAL
+--- xbmc/linux/HALManager.h.orig	2016-09-03 UTC
++++ xbmc/linux/HALManager.h
+@@ -0,0 +1,166 @@
++#ifdef HAS_HAL
++#ifndef HALMANAGER_H
++#define HALMANAGER_H
++
++/*
++ *      Copyright (C) 2005-2013 Team XBMC
++ *      http://xbmc.org
++ *
++ *  This Program is free software; you can redistribute it and/or modify
++ *  it under the terms of the GNU General Public License as published by
++ *  the Free Software Foundation; either version 2, or (at your option)
++ *  any later version.
++ *
++ *  This Program is distributed in the hope that it will be useful,
++ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ *  GNU General Public License for more details.
++ *
++ *  You should have received a copy of the GNU General Public License
++ *  along with XBMC; see the file COPYING.  If not, see
++ *  <http://www.gnu.org/licenses/>.
++ *
++ */
++
++#include "system.h"
++#include <string.h>
++#include <stdio.h>
++#include <dbus/dbus.h>
++#include <libhal.h>
++#include <vector>
++
++#define BYTE char
++#include "utils/log.h"
++#include "threads/CriticalSection.h"
++#include "utils/StringUtils.h"
++#include "utils/URIUtils.h"
++#include "MediaSource.h"
++
++class CHALDevice
++{
++public:
++  std::string UDI;
++  std::string FriendlyName;
++  CHALDevice(const char *udi) { UDI = udi; }
++};
++
++class CStorageDevice : public CHALDevice
++{
++public:
++  CStorageDevice(const char *udi) : CHALDevice(udi) { HotPlugged = false; Mounted = false; Approved = false; MountedByXBMC = false; }
++  bool MountedByXBMC;
++  bool Mounted;
++  bool Approved;
++  bool HotPlugged;
++  bool HalIgnore;
++  std::string MountPoint;
++  std::string Label;
++  std::string UUID;
++  std::string DevID;
++  int  Type;
++  std::string FileSystem;
++
++  std::string toString()
++  { // Not the prettiest but it's better than having to reproduce it elsewere in the code...
++    std::string rtn, tmp1, tmp2, tmp3, tmp4;
++    if (UUID.size() > 0)
++      tmp1 = StringUtils::Format("UUID %s | ", UUID.c_str());
++    if (FileSystem.size() > 0)
++      tmp2 = StringUtils::Format("FileSystem %s | ", FileSystem.c_str());
++    if (MountPoint.size() > 0)
++      tmp3 = StringUtils::Format("Mounted on %s | ", MountPoint.c_str());
++    if (HotPlugged)
++      tmp4 = StringUtils::Format("HotPlugged YES | ");
++    else
++      tmp4 = StringUtils::Format("HotPlugged NO  | ");
++
++    if (Approved)
++      rtn = StringUtils::Format("%s%s%s%sType %i |Approved YES ", tmp1.c_str(), tmp2.c_str(), tmp3.c_str(), tmp4.c_str(), Type);
++    else
++      rtn = StringUtils::Format("%s%s%s%sType %i |Approved NO  ", tmp1.c_str(), tmp2.c_str(), tmp3.c_str(), tmp4.c_str(), Type);
++
++    return  rtn;
++  }
++  void toMediaSource(CMediaSource *share)
++  {
++    share->strPath = MountPoint;
++    if (Label.size() > 0)
++      share->strName = Label;
++    else
++    {
++      share->strName = MountPoint;
++      URIUtils::RemoveSlashAtEnd(share->strName);
++      share->strName = URIUtils::GetFileName(share->strName);
++    }
++
++    share->m_ignore = true;
++    if (HotPlugged)
++      share->m_iDriveType = CMediaSource::SOURCE_TYPE_REMOVABLE;
++    else if(strcmp(FileSystem.c_str(), "iso9660") == 0 || strcmp(FileSystem.c_str(), "udf") == 0)
++      share->m_iDriveType = CMediaSource::SOURCE_TYPE_DVD;
++    else
++      share->m_iDriveType = CMediaSource::SOURCE_TYPE_LOCAL;
++  }
++
++};
++
++
++class CHALManager
++{
++public:
++  static const char *StorageTypeToString(int DeviceType);
++  static int StorageTypeFromString(const char *DeviceString);
++  bool Update();
++
++  void Initialize();
++  CHALManager();
++  void Stop();
++  std::vector<CStorageDevice> GetVolumeDevices();
++  bool Eject(const std::string &path);
++protected:
++  DBusConnection *m_DBusSystemConnection;
++  LibHalContext  *m_Context;
++  static DBusError m_Error;
++  static bool NewMessage;
++
++
++  void UpdateDevice(const char *udi);
++  void AddDevice(const char *udi);
++  bool RemoveDevice(const char *udi);
++
++private:
++  bool m_Notifications;
++  LibHalContext *InitializeHal();
++  bool InitializeDBus();
++  void GenerateGDL();
++
++  bool UnMount(CStorageDevice volume);
++  bool Mount(CStorageDevice *volume, const std::string& mountpath);
++  void HandleNewVolume(CStorageDevice *dev);
++  static bool ApproveDevice(CStorageDevice *device);
++
++  static bool DeviceFromVolumeUdi(const char *udi, CStorageDevice *device);
++  static CCriticalSection m_lock;
++
++#if defined(HAS_SDL_JOYSTICK)
++  bool m_bMultipleJoysticksSupport;
++#endif
++
++  //Callbacks HAL
++  static void DeviceRemoved(LibHalContext *ctx, const char *udi);
++  static void DeviceNewCapability(LibHalContext *ctx, const char *udi, const char *capability);
++  static void DeviceLostCapability(LibHalContext *ctx, const char *udi, const char *capability);
++  static void DevicePropertyModified(LibHalContext *ctx, const char *udi, const char *key, dbus_bool_t is_removed, dbus_bool_t is_added);
++  static void DeviceCondition(LibHalContext *ctx, const char *udi, const char *condition_name, const char *condition_details);
++  static void DeviceAdded(LibHalContext *ctx, const char *udi);
++
++  //Remembered Devices
++  std::vector<CStorageDevice> m_Volumes;
++#if defined(HAS_SDL_JOYSTICK)
++  std::vector<CHALDevice> m_Joysticks;
++#endif
++};
++
++extern CHALManager g_HalManager;
++#endif
++#endif // HAS_HAL
+--- xbmc/linux/Makefile.in.orig	2016-09-03 UTC
++++ xbmc/linux/Makefile.in
+@@ -4,6 +4,7 @@ SRCS  = ConvUtils.cpp
+ SRCS += DBusUtil.cpp
+ SRCS += DBusMessage.cpp
+ SRCS += DBusReserve.cpp
++SRCS += HALManager.cpp
+ SRCS += FDEventMonitor.cpp
+ SRCS += LinuxResourceCounter.cpp
+ SRCS += LinuxTimezone.cpp
+--- xbmc/powermanagement/linux/HALPowerSyscall.cpp.orig	2016-09-03 UTC
++++ xbmc/powermanagement/linux/HALPowerSyscall.cpp
+@@ -0,0 +1,159 @@
++/*
++ *      Copyright (C) 2005-2013 Team XBMC
++ *      http://xbmc.org
++ *
++ *  This Program is free software; you can redistribute it and/or modify
++ *  it under the terms of the GNU General Public License as published by
++ *  the Free Software Foundation; either version 2, or (at your option)
++ *  any later version.
++ *
++ *  This Program is distributed in the hope that it will be useful,
++ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ *  GNU General Public License for more details.
++ *
++ *  You should have received a copy of the GNU General Public License
++ *  along with XBMC; see the file COPYING.  If not, see
++ *  <http://www.gnu.org/licenses/>.
++ *
++ */
++
++#include "system.h"
++#include "HALPowerSyscall.h"
++#include "utils/log.h"
++
++#ifdef HAS_HAL
++#include <dbus/dbus.h>
++#include <stdlib.h>
++
++CHALPowerSyscall::CHALPowerSyscall()
++{
++  m_CanPowerdown = true;
++  m_CanSuspend   = QueryCapability("power_management.can_suspend");
++  m_CanHibernate = QueryCapability("power_management.can_hibernate");
++  m_CanReboot    = true;
++}
++
++bool CHALPowerSyscall::Powerdown()
++{
++  return doPowerCall("Shutdown");
++}
++bool CHALPowerSyscall::Suspend()
++{
++  CPowerSyscallWithoutEvents::Suspend();
++  return doPowerCall("Suspend");
++}
++bool CHALPowerSyscall::Hibernate()
++{
++  CPowerSyscallWithoutEvents::Hibernate();
++  return doPowerCall("Hibernate");
++}
++bool CHALPowerSyscall::Reboot()
++{
++  return doPowerCall("Reboot");
++}
++
++bool CHALPowerSyscall::CanPowerdown()
++{
++  return m_CanPowerdown;
++}
++bool CHALPowerSyscall::CanSuspend()
++{
++  return m_CanSuspend;
++}
++bool CHALPowerSyscall::CanHibernate()
++{
++  return m_CanHibernate;
++}
++bool CHALPowerSyscall::CanReboot()
++{
++  return m_CanReboot;
++}
++
++int CHALPowerSyscall::BatteryLevel()
++{
++  return 0;
++}
++
++bool CHALPowerSyscall::doPowerCall(const char *powerstate)
++{
++  DBusMessage* msg;
++  DBusMessageIter args;
++  DBusError error;
++  dbus_error_init (&error);
++  DBusConnection *connection = dbus_bus_get (DBUS_BUS_SYSTEM, &error);
++  dbus_int32_t int32 = 0;
++  if (connection)
++  {
++    bool result = false;
++    msg = dbus_message_new_method_call("org.freedesktop.Hal", "/org/freedesktop/Hal/devices/computer", "org.freedesktop.Hal.Device.SystemPowerManagement", powerstate);
++
++    if (msg && strcmp(powerstate, "Suspend") == 0)
++    {
++      dbus_message_iter_init_append(msg, &args);
++      if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &int32))
++        CLog::Log(LOGERROR, "DBus: Failed to append arguments");
++    }
++    if (msg == NULL)
++      CLog::Log(LOGERROR, "DBus: Create PowerManagement Message failed");
++    else
++    {
++      result = dbus_connection_send(connection, msg, NULL);
++      // Need to create a reader for the Message
++      dbus_message_unref(msg);
++      msg = NULL;
++    }
++
++    dbus_connection_unref(connection);
++    connection = NULL;
++    return result;
++  }
++  return false;
++}
++
++bool CHALPowerSyscall::QueryCapability(const char *capability)
++{
++  DBusMessage* msg;
++  DBusMessageIter args;
++  DBusError error;
++  dbus_error_init (&error);
++  DBusConnection *connection = dbus_bus_get (DBUS_BUS_SYSTEM, &error);
++  if (connection)
++  {
++    msg = dbus_message_new_method_call("org.freedesktop.Hal", "/org/freedesktop/Hal/devices/computer", "org.freedesktop.Hal.Device", "GetProperty");
++
++    dbus_message_iter_init_append(msg, &args);
++    if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &capability))
++      return false;
++
++    if (msg == NULL)
++      return false;
++
++    DBusMessage *reply;
++    reply = dbus_connection_send_with_reply_and_block(connection, msg, -1, &error);
++    if (reply == NULL)
++    {
++      if (dbus_error_is_set(&error))
++        dbus_error_free(&error);
++
++      dbus_message_unref(msg);
++      return false;
++    }
++
++    dbus_bool_t b = false;
++    dbus_message_get_args(reply, &error, DBUS_TYPE_BOOLEAN, &b);
++
++    if (dbus_error_is_set(&error))
++      dbus_error_free(&error);
++
++    dbus_message_unref(reply);
++    dbus_message_unref(msg);
++    msg = NULL;
++    return b;
++  }
++
++  if (dbus_error_is_set(&error))
++    dbus_error_free(&error);
++  return false;
++}
++#endif
+--- xbmc/powermanagement/linux/HALPowerSyscall.h.orig	2016-09-03 UTC
++++ xbmc/powermanagement/linux/HALPowerSyscall.h
+@@ -0,0 +1,50 @@
++/*
++ *      Copyright (C) 2005-2013 Team XBMC
++ *      http://xbmc.org
++ *
++ *  This Program is free software; you can redistribute it and/or modify
++ *  it under the terms of the GNU General Public License as published by
++ *  the Free Software Foundation; either version 2, or (at your option)
++ *  any later version.
++ *
++ *  This Program is distributed in the hope that it will be useful,
++ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ *  GNU General Public License for more details.
++ *
++ *  You should have received a copy of the GNU General Public License
++ *  along with XBMC; see the file COPYING.  If not, see
++ *  <http://www.gnu.org/licenses/>.
++ *
++ */
++#pragma once
++#include "powermanagement/IPowerSyscall.h"
++#include "system.h"
++#ifdef HAS_HAL
++
++class CHALPowerSyscall : public CPowerSyscallWithoutEvents
++{
++public:
++  CHALPowerSyscall();
++
++  virtual bool Powerdown();
++  virtual bool Suspend();
++  virtual bool Hibernate();
++  virtual bool Reboot();
++
++  virtual bool CanPowerdown();
++  virtual bool CanSuspend();
++  virtual bool CanHibernate();
++  virtual bool CanReboot();
++  virtual int  BatteryLevel();
++
++private:
++  bool QueryCapability(const char *capability);
++  bool doPowerCall(const char *powerstate);
++
++  bool m_CanPowerdown;
++  bool m_CanSuspend;
++  bool m_CanHibernate;
++  bool m_CanReboot;
++};
++#endif
+--- xbmc/powermanagement/linux/Makefile.orig	2016-09-03 UTC
++++ xbmc/powermanagement/linux/Makefile
+@@ -1,5 +1,6 @@
+ SRCS=ConsoleDeviceKitPowerSyscall.cpp \
+      ConsoleUPowerSyscall.cpp \
++     HALPowerSyscall.cpp \
+      UPowerSyscall.cpp \
+      LogindUPowerSyscall.cpp
+ 
+--- xbmc/powermanagement/PowerManager.cpp.orig	2016-04-24 UTC
++++ xbmc/powermanagement/PowerManager.cpp
+@@ -50,6 +50,9 @@
+ #include "linux/ConsoleDeviceKitPowerSyscall.h"
+ #include "linux/LogindUPowerSyscall.h"
+ #include "linux/UPowerSyscall.h"
++#if defined(HAS_HAL)
++#include "linux/HALPowerSyscall.h"
++#endif // HAS_HAL
+ #endif // HAS_DBUS
+ #elif defined(TARGET_WINDOWS)
+ #include "powermanagement/windows/Win32PowerSyscall.h"
+@@ -74,7 +77,9 @@ void CPowerManager::Initialize()
+ {
+   SAFE_DELETE(m_instance);
+ 
+-#if defined(TARGET_DARWIN)
++#if defined(TARGET_RASPBERRY_PI)
++  m_instance = new CHALPowerSyscall();
++#elif defined(TARGET_DARWIN)
+   m_instance = new CCocoaPowerSyscall();
+ #elif defined(TARGET_ANDROID)
+   m_instance = new CAndroidPowerSyscall();
+--- xbmc/storage/linux/HALProvider.cpp.orig	2016-09-03 UTC
++++ xbmc/storage/linux/HALProvider.cpp
+@@ -0,0 +1,94 @@
++/*
++ *      Copyright (C) 2005-2013 Team XBMC
++ *      http://xbmc.org
++ *
++ *  This Program is free software; you can redistribute it and/or modify
++ *  it under the terms of the GNU General Public License as published by
++ *  the Free Software Foundation; either version 2, or (at your option)
++ *  any later version.
++ *
++ *  This Program is distributed in the hope that it will be useful,
++ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ *  GNU General Public License for more details.
++ *
++ *  You should have received a copy of the GNU General Public License
++ *  along with XBMC; see the file COPYING.  If not, see
++ *  <http://www.gnu.org/licenses/>.
++ *
++ */
++#include "HALProvider.h"
++#ifdef HAS_HAL
++#include "HALManager.h"
++#include "utils/log.h"
++#include "PosixMountProvider.h"
++
++CHALProvider::CHALProvider()
++{
++  m_removableLength = 0;
++}
++
++void CHALProvider::Initialize()
++{
++  CLog::Log(LOGDEBUG, "Selected HAL as storage provider");
++  g_HalManager.Initialize();
++  PumpDriveChangeEvents(NULL);
++}
++
++void CHALProvider::Stop()
++{
++  g_HalManager.Stop();
++}
++
++void CHALProvider::GetLocalDrives(VECSOURCES &localDrives)
++{
++  std::vector<CStorageDevice> devices = g_HalManager.GetVolumeDevices();
++
++  for (size_t i = 0; i < devices.size(); i++)
++  {
++    if (devices[i].Mounted && devices[i].Approved && !devices[i].HotPlugged)
++    {
++      CMediaSource share;
++      devices[i].toMediaSource(&share);
++      localDrives.push_back(share);
++    }
++  }
++}
++
++void CHALProvider::GetRemovableDrives(VECSOURCES &removableDrives)
++{
++  std::vector<CStorageDevice> devices = g_HalManager.GetVolumeDevices();
++
++  for (size_t i = 0; i < devices.size(); i++)
++  {
++    if (devices[i].Mounted && devices[i].Approved && devices[i].HotPlugged)
++    {
++      CMediaSource share;
++      devices[i].toMediaSource(&share);
++      removableDrives.push_back(share);
++    }
++  }
++}
++
++bool CHALProvider::Eject(const std::string& mountpath)
++{
++  return g_HalManager.Eject(mountpath);
++}
++
++std::vector<std::string> CHALProvider::GetDiskUsage()
++{
++  CPosixMountProvider legacy;
++  return legacy.GetDiskUsage();
++}
++
++// TODO Use HALs events for this instead.
++bool CHALProvider::PumpDriveChangeEvents(IStorageEventsCallback *callback)
++{
++//Pump HalManager dry of events
++  bool changed = false;
++  while (g_HalManager.Update())
++    changed = true;
++
++  return changed;
++}
++#endif
+--- xbmc/storage/linux/HALProvider.h.orig	2016-09-03 UTC
++++ xbmc/storage/linux/HALProvider.h
+@@ -0,0 +1,44 @@
++#pragma once
++/*
++ *      Copyright (C) 2005-2013 Team XBMC
++ *      http://xbmc.org
++ *
++ *  This Program is free software; you can redistribute it and/or modify
++ *  it under the terms of the GNU General Public License as published by
++ *  the Free Software Foundation; either version 2, or (at your option)
++ *  any later version.
++ *
++ *  This Program is distributed in the hope that it will be useful,
++ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ *  GNU General Public License for more details.
++ *
++ *  You should have received a copy of the GNU General Public License
++ *  along with XBMC; see the file COPYING.  If not, see
++ *  <http://www.gnu.org/licenses/>.
++ *
++ */
++#include "storage/IStorageProvider.h"
++#ifdef HAS_HAL
++
++class CHALProvider : public IStorageProvider
++{
++public:
++  CHALProvider();
++  virtual ~CHALProvider() { }
++
++  virtual void Initialize();
++  virtual void Stop();
++
++  virtual void GetLocalDrives(VECSOURCES &localDrives);
++  virtual void GetRemovableDrives(VECSOURCES &removableDrives);
++
++  virtual bool Eject(const std::string& mountpath);
++
++  virtual std::vector<std::string> GetDiskUsage();
++
++  virtual bool PumpDriveChangeEvents(IStorageEventsCallback *callback);
++private:
++  unsigned int m_removableLength;
++};
++#endif
+--- xbmc/storage/linux/LinuxStorageProvider.h.orig	2016-04-24 UTC
++++ xbmc/storage/linux/LinuxStorageProvider.h
+@@ -19,6 +19,7 @@
+  *
+  */
+ #include "storage/IStorageProvider.h"
++#include "HALProvider.h"
+ #include "DeviceKitDisksProvider.h"
+ #include "UDevProvider.h"
+ #include "UDisksProvider.h"
+@@ -37,6 +38,10 @@ public:
+     else if (CDeviceKitDisksProvider::HasDeviceKitDisks())
+       m_instance = new CDeviceKitDisksProvider();
+ #endif
++#ifdef HAS_HAL
++    if (m_instance == NULL)
++      m_instance = new CHALProvider();
++#endif
+ #ifdef HAVE_LIBUDEV
+     if (m_instance == NULL)
+       m_instance = new CUDevProvider();
+--- xbmc/storage/linux/Makefile.orig	2016-09-03 UTC
++++ xbmc/storage/linux/Makefile
+@@ -1,5 +1,6 @@
+ SRCS  = DeviceKitDisksProvider.cpp
+ SRCS += UDisksProvider.cpp
++SRCS += HALProvider.cpp
+ SRCS += UDevProvider.cpp
+      
+ LIB = storage_linux.a