[addon] add API level 2 add-on static library

65 files changed, 6614 insertions, 1 deletions

diff --git a/xbmc/addons/kodi-addon-dev-kit/.gitignore b/xbmc/addons/kodi-addon-dev-kit/.gitignore
index 039c6a72a8..08cbb2ccdb 100644
--- a/xbmc/addons/kodi-addon-dev-kit/.gitignore
+++ b/xbmc/addons/kodi-addon-dev-kit/.gitignore
@@ -29,3 +29,5 @@
 
 /docs
 /build
+.cmake-kit
+.create-kit
diff --git a/xbmc/addons/kodi-addon-dev-kit/CMakeLists.txt b/xbmc/addons/kodi-addon-dev-kit/CMakeLists.txt
new file mode 100644
index 0000000000..e0066460f0
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/CMakeLists.txt
@@ -0,0 +1,18 @@
+project(kodi-addon-dev-kit)
+
+cmake_minimum_required(VERSION 3.0.0)
+
+# add a target to generate API documentation with Doxygen
+find_package(Doxygen)
+
+if(DOXYGEN_FOUND)
+  add_custom_target(doc
+    ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/doxygen/Doxyfile
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+    COMMENT "Generating API documentation with Doxygen" VERBATIM
+  )
+endif(DOXYGEN_FOUND)
+
+add_subdirectory(src/api2/kodi-addon-sharedlibrary)
+
+install(DIRECTORY include/kodi DESTINATION include)
diff --git a/xbmc/addons/kodi-addon-dev-kit/LICENSE.GPL b/xbmc/addons/kodi-addon-dev-kit/LICENSE.GPL
new file mode 100644
index 0000000000..3f9ab9609f
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/LICENSE.GPL
@@ -0,0 +1,287 @@
+1
+ You may use, distribute and copy Kodi under the terms of GNU General
+ Public License version 2, which is displayed below.
+
+-------------------------------------------------------------------------
+
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                       59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+-------------------------------------------------------------------------
diff --git a/xbmc/addons/kodi-addon-dev-kit/PkgConfigHandler.cmake b/xbmc/addons/kodi-addon-dev-kit/PkgConfigHandler.cmake
new file mode 100644
index 0000000000..52c28df3ed
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/PkgConfigHandler.cmake
@@ -0,0 +1,97 @@
+# translate a list of libraries into a command-line that can be passed to the
+# compiler/linker. first parameter is the name of the variable that will
+# receive this list, the rest is considered the list of libraries
+function (linker_cmdline what INTO outvar FROM)
+  # if we are going to put these in regexps, we must escape period
+  string (REPLACE "." "\\." esc_dl_pref "${CMAKE_SHARED_LIBRARY_PREFIX}")
+  string (REPLACE "." "\\." esc_dl_suff "${CMAKE_SHARED_LIBRARY_SUFFIX}")
+  string (REPLACE "." "\\." esc_ar_pref "${CMAKE_STATIC_LIBRARY_PREFIX}")
+  string (REPLACE "." "\\." esc_ar_suff "${CMAKE_STATIC_LIBRARY_PREFIX}")
+
+  # CMake loves absolute paths, whereas libtool won't have any of it!
+  # (you get an error message about argument not parsed). translate each
+  # of the libraries into a linker option
+  set (deplib_list "")
+  foreach (deplib IN LISTS ARGN)
+        # starts with a hyphen already? then just add it
+        string (SUBSTRING ${deplib} 0 1 dash)
+        if (${dash} STREQUAL "-")
+          list (APPEND deplib_list ${deplib})
+        else (${dash} STREQUAL "-")
+          # otherwise, parse the name into a directory and a name
+          get_filename_component (deplib_dir ${deplib} PATH)
+          get_filename_component (deplib_orig ${deplib} NAME)
+          string (REGEX REPLACE
+                "^${esc_dl_pref}(.*)${esc_dl_suff}$"
+                "\\1"
+                deplib_name
+                ${deplib_orig}
+                )
+          string (REGEX REPLACE
+                "^${esc_ar_pref}(.*)${esc_ar_suff}$"
+                "\\1"
+                deplib_name
+                ${deplib_name}
+                )
+          # directory and name each on their own; this is somewhat
+          # unsatisfactory because it may be that a system dir is specified
+          # by an earlier directory and you start picking up libraries from
+          # there instead of the "closest" path here. also, the soversion
+          # is more or less lost. remove system default path, to lessen the
+          # chance that we pick the wrong library
+          if (NOT ((deplib_dir STREQUAL "/usr/lib") OR
+                           (deplib_dir STREQUAL "/usr/${CMAKE_INSTALL_LIBDIR}")))
+                   list (APPEND deplib_list "-L${deplib_dir}")
+          endif (NOT ((deplib_dir STREQUAL "/usr/lib") OR
+                              (deplib_dir STREQUAL "/usr/${CMAKE_INSTALL_LIBDIR}")))
+          # if there was no translation of the name, the library is named
+          # unconventionally (.so.3gf, I'm looking at you), so pass this
+          # name unmodified to the linker switch
+          if (deplib_orig STREQUAL deplib_name)
+                list (APPEND deplib_list "-l:${deplib_orig}")
+          else (deplib_orig STREQUAL deplib_name)
+                list (APPEND deplib_list "-l${deplib_name}")
+          endif (deplib_orig STREQUAL deplib_name)
+        endif (${dash} STREQUAL "-")
+  endforeach (deplib)
+  # caller determines whether we want it returned as a list or a string
+  if ("${what}" STREQUAL "LIST")
+        set (${outvar} ${deplib_list})
+  else ("${what}" STREQUAL "LIST")
+        set (${outvar} "${deplib_list}")
+        string (REPLACE ";" " " ${outvar} "${${outvar}}")
+  endif ("${what}" STREQUAL "LIST")
+  set (${outvar} "${${outvar}}" PARENT_SCOPE)
+endfunction (linker_cmdline what INTO outvar FROM)
+
+# convert a list back to a command-line string
+function (unseparate_args var_name prefix value)
+  separate_arguments (value)
+  foreach (item IN LISTS value)
+        set (prefixed_item "${prefix}${item}")
+        if (${var_name})
+          set (${var_name} "${${var_name}} ${prefixed_item}")
+        else (${var_name})
+          set (${var_name} "${prefixed_item}")
+        endif (${var_name})
+  endforeach (item)
+  set (${var_name} "${${var_name}}" PARENT_SCOPE)
+endfunction (unseparate_args var_name prefix value)
+
+# wrapper to set variables in pkg-config file
+function (configure_pc_file name source dest prefix libdir includedir)
+  # escape set of standard strings
+  unseparate_args (includes "-I" "${${name}_INCLUDE_DIRS}")
+  unseparate_args (defs "" "${${name}_DEFINITIONS}")
+  linker_cmdline (STRING INTO libs FROM ${${name}_LIBRARIES})
+
+  # necessary to make these variables visible to configure_file
+  set (name "${${name}_NAME}")
+  set (description "${${name}_DESCRIPTION}")
+  set (major "${${name}_VERSION_MAJOR}")
+  set (minor "${${name}_VERSION_MINOR}")
+  set (target "${name}")
+  linker_cmdline (STRING INTO target from ${target})
+
+  configure_file (${source} ${dest} @ONLY)
+endfunction (configure_pc_file name source dist prefix libdir includedir)
diff --git a/xbmc/addons/kodi-addon-dev-kit/UseMultiArch.cmake b/xbmc/addons/kodi-addon-dev-kit/UseMultiArch.cmake
new file mode 100644
index 0000000000..1e338f68cc
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/UseMultiArch.cmake
@@ -0,0 +1,49 @@
+# - Multiarch support in object code library directories
+#
+# This module sets the following variable
+#	CMAKE_INSTALL_LIBDIR	     to lib, lib64 or lib/x86_64-linux-gnu
+#	                             depending on the platform; use this path
+#	                             for platform-specific binaries.
+#
+#	CMAKE_INSTALL_LIBDIR_NOARCH  to lib or lib64 depending on the platform;
+#	                             use this path for architecture-independent
+#	                             files.
+#
+# Note that it will override the results of GNUInstallDirs if included after
+# that module.
+
+# Fedora uses lib64/ for 64-bit systems, Debian uses lib/x86_64-linux-gnu;
+# Fedora put module files in lib64/ too, but Debian uses lib/ for that
+if ("${CMAKE_SYSTEM_NAME}" MATCHES "Linux" AND
+    "${CMAKE_INSTALL_PREFIX}" STREQUAL "/usr")
+  # Debian or Ubuntu?
+  if (EXISTS "/etc/debian_version")
+	set (_libdir_def "lib/${CMAKE_LIBRARY_ARCHITECTURE}")
+	set (_libdir_noarch "lib")
+  elseif (EXISTS "/etc/fedora-release" OR
+          EXISTS "/etc/redhat-release" OR
+          EXISTS "/etc/slackware-version" OR
+          EXISTS "/etc/gentoo-release")
+	# 64-bit system?
+	if (CMAKE_SIZEOF_VOID_P EQUAL 8)
+	  set (_libdir_noarch "lib64")
+	else (CMAKE_SIZEOF_VOID_P EQUAL 8)
+	  set (_libdir_noarch "lib")
+	endif (CMAKE_SIZEOF_VOID_P EQUAL 8)
+	set (_libdir_def "${_libdir_noarch}")
+  else ()
+    set (_libdir_def "lib")
+    set (_libdir_noarch "lib")
+  endif ()
+else ()
+  set (_libdir_def "lib")
+  set (_libdir_noarch "lib")
+endif ()
+
+# let the user override if somewhere else is desirable
+set (CMAKE_INSTALL_LIBDIR "${_libdir_def}" CACHE PATH "Object code libraries")
+set (CMAKE_INSTALL_LIBDIR_NOARCH "${_libdir_noarch}" CACHE PATH "Architecture-independent library files")
+mark_as_advanced (
+  CMAKE_INSTALL_LIBDIR
+  CMAKE_INSTALL_LIBDIR_NOARCH
+  )
diff --git a/xbmc/addons/kodi-addon-dev-kit/doxygen/Doxyfile b/xbmc/addons/kodi-addon-dev-kit/doxygen/Doxyfile
index 13a35a1987..2db19ea96b 100644
--- a/xbmc/addons/kodi-addon-dev-kit/doxygen/Doxyfile
+++ b/xbmc/addons/kodi-addon-dev-kit/doxygen/Doxyfile
@@ -783,6 +783,7 @@ INPUT                  = main.txt \
                          ../../../GUIInfoManager.cpp \
                          Modules/modules_general.dox \
                          Modules/modules_python.dox \
+                         Modules/modules_cpp.dox \
                          Skin/skin.dox \
                          ../../../guilib/GUIRenderingControl.dox \
                          ../../../guilib/GUIButtonControl.dox \
@@ -856,6 +857,57 @@ INPUT                  = main.txt \
                          ../../../interfaces/legacy/wsgi/WsgiResponseBody.h \
                          ../../../interfaces/legacy/wsgi/WsgiResponse.h \
                          ../../../pictures/PictureInfoTag.cpp
+                         ../include/kodi/api2/AddonLib.hpp \
+                         ../include/kodi/api2/definitions-all.hpp \
+                         ../include/kodi/api2/definitions.hpp \
+                         ../include/kodi/api2/addon/definitions_addon.hpp \
+                         ../include/kodi/api2/addon/General.hpp \
+                         ../include/kodi/api2/addon/SoundPlay.hpp \
+                         ../include/kodi/api2/addon/Network.hpp \
+                         ../include/kodi/api2/addon/VFSUtils.hpp \
+                         ../include/kodi/api2/audioengine/definitions_audioengine.hpp \
+                         ../include/kodi/api2/audioengine/General.hpp \
+                         ../include/kodi/api2/audioengine/Stream.hpp \
+                         ../include/kodi/api2/gui/definitions_gui.hpp \
+                         ../include/kodi/api2/gui/General.hpp \
+                         ../include/kodi/api2/gui/Window.hpp \
+                         ../include/kodi/api2/gui/ListItem.hpp \
+                         ../include/kodi/api2/gui/DialogContextMenu.hpp \
+                         ../include/kodi/api2/gui/DialogExtendedProgress.hpp \
+                         ../include/kodi/api2/gui/DialogFileBrowser.hpp \
+                         ../include/kodi/api2/gui/DialogKeyboard.hpp \
+                         ../include/kodi/api2/gui/DialogNumeric.hpp \
+                         ../include/kodi/api2/gui/DialogOK.hpp \
+                         ../include/kodi/api2/gui/DialogProgress.hpp \
+                         ../include/kodi/api2/gui/DialogSelect.hpp \
+                         ../include/kodi/api2/gui/DialogTextViewer.hpp \
+                         ../include/kodi/api2/gui/DialogYesNo.hpp \
+                         ../include/kodi/api2/gui/ControlButton.hpp \
+                         ../include/kodi/api2/gui/ControlEdit.hpp \
+                         ../include/kodi/api2/gui/ControlFadeLabel.hpp \
+                         ../include/kodi/api2/gui/ControlImage.hpp \
+                         ../include/kodi/api2/gui/ControlLabel.hpp \
+                         ../include/kodi/api2/gui/ControlProgress.hpp \
+                         ../include/kodi/api2/gui/ControlRadioButton.hpp \
+                         ../include/kodi/api2/gui/ControlRendering.hpp \
+                         ../include/kodi/api2/gui/ControlSettingsSlider.hpp \
+                         ../include/kodi/api2/gui/ControlSlider.hpp \
+                         ../include/kodi/api2/gui/ControlSpin.hpp \
+                         ../include/kodi/api2/gui/ControlTextBox.hpp \
+                         ../include/kodi/api2/inputstream/definitions_inputstream.hpp \
+                         ../include/kodi/api2/inputstream/InputStream.hpp \
+                         ../include/kodi/api2/peripheral/definitions_peripheral.hpp \
+                         ../include/kodi/api2/peripheral/Peripheral.hpp \
+                         ../include/kodi/api2/player/Player.hpp \
+                         ../include/kodi/api2/player/PlayList.hpp \
+                         ../include/kodi/api2/player/definitions_player.hpp \
+                         ../include/kodi/api2/player/InfoTagMusic.hpp \
+                         ../include/kodi/api2/player/InfoTagVideo.hpp \
+                         ../include/kodi/api2/pvr/definitions_pvr.hpp \
+                         ../include/kodi/api2/pvr/General.hpp \
+                         ../include/kodi/api2/pvr/StreamUtils.hpp \
+                         ../include/kodi/api2/pvr/Transfer.hpp \
+                         ../include/kodi/api2/pvr/Trigger.hpp
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
diff --git a/xbmc/addons/kodi-addon-dev-kit/doxygen/Modules/logo-cpp.png b/xbmc/addons/kodi-addon-dev-kit/doxygen/Modules/logo-cpp.png
new file mode 100644
index 0000000000..870065eb44
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/doxygen/Modules/logo-cpp.png
diff --git a/xbmc/addons/kodi-addon-dev-kit/doxygen/Modules/modules_cpp.dox b/xbmc/addons/kodi-addon-dev-kit/doxygen/Modules/modules_cpp.dox
new file mode 100644
index 0000000000..c0b8b775e0
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/doxygen/Modules/modules_cpp.dox
@@ -0,0 +1,14 @@
+namespace V2
+{
+/*!
+
+\defgroup cpp C++
+\image html logo-cpp.png
+\brief \htmlonly
+      <h3><span  style="text-decoration: underline;"><span  style="font-style: italic;"><span
+               style="color: rgb(102, 102, 102);">C++ Binary Add-On Development</span></span></span></h3>
+       \endhtmlonly
+
+*/
+
+};
diff --git a/xbmc/addons/kodi-addon-dev-kit/doxygen/Modules/modules_general.dox b/xbmc/addons/kodi-addon-dev-kit/doxygen/Modules/modules_general.dox
index 481a0db8d6..fcb9febf6e 100644
--- a/xbmc/addons/kodi-addon-dev-kit/doxygen/Modules/modules_general.dox
+++ b/xbmc/addons/kodi-addon-dev-kit/doxygen/Modules/modules_general.dox
@@ -4,5 +4,6 @@
 \brief \doc_header{ General Add-On Development parts }
 
 \subpage modules__General__List_of_gui_access
+
 \subpage page_List_of_built_in_functions
 */
diff --git a/xbmc/addons/kodi-addon-dev-kit/include/kodi/api2/gui/ListItem.hpp b/xbmc/addons/kodi-addon-dev-kit/include/kodi/api2/gui/ListItem.hpp
index 51a9c895d6..d4bbf06499 100644
--- a/xbmc/addons/kodi-addon-dev-kit/include/kodi/api2/gui/ListItem.hpp
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/api2/gui/ListItem.hpp
@@ -53,7 +53,7 @@ namespace GUI
   ///
   /// The list item control is used for creating item lists in Kodi
   ///
-  /// The with \ref ListItem.hpp "#include <kodi/api3/addon/IListItem.hpp>" given
+  /// The with \ref ListItem.hpp "#include <kodi/api2/addon/IListItem.hpp>" given
   /// class is used to create a item entry for a list on window and to support it's
   /// control.
   ///
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/dev-kit-api-level.cmake b/xbmc/addons/kodi-addon-dev-kit/src/api2/dev-kit-api-level.cmake
new file mode 100644
index 0000000000..7eab848c72
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/dev-kit-api-level.cmake
@@ -0,0 +1,2 @@
+SET(ADDON_API_LEVEL 2)
+SET(ADDON_API_VERSION 2.0.0)
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/AddonLib.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/AddonLib.cpp
new file mode 100644
index 0000000000..e4533c801d
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/AddonLib.cpp
@@ -0,0 +1,63 @@
+/*
+ *      Copyright (C) 2015-2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, AddonLib.hpp)
+
+#include "../version.h"
+
+#include <string>
+#include <stdarg.h>     /* va_list, va_start, va_arg, va_end */
+#include <stdio.h>
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+extern "C"
+{
+
+int KODI_API_Level = ADDON_API_LEVEL;
+const char* KODI_API_Version  = ADDON_API_VERSION;
+
+int InitLibAddon(void* hdl)
+{
+  return g_interProcess.InitLibAddon(hdl);
+}
+
+int Finalize()
+{
+  return g_interProcess.Finalize();
+}
+
+void Log(const addon_log loglevel, const char* format, ... )
+{
+  char buffer[16384];
+  va_list args;
+  va_start(args, format);
+  vsprintf(buffer, format, args);
+  va_end(args);
+  g_interProcess.Log(loglevel, buffer);
+}
+
+} /* extern "C" */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/CMakeLists.txt b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/CMakeLists.txt
new file mode 100644
index 0000000000..684c3faf79
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/CMakeLists.txt
@@ -0,0 +1,108 @@
+project(kodi-addon-sharedlibrary-api2)
+
+cmake_minimum_required(VERSION 3.0.0)
+
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR})
+
+enable_language(C CXX)
+
+include(../dev-kit-api-level.cmake)
+include(../../../UseMultiArch.cmake)
+
+set(kodi-addon-sharedlibrary_NAME kodi-addon-sharedlibrary)
+set(kodi-addon-sharedlibrary_DESCRIPTION "Kodi add-on API 3 development kit for shared libraries")
+set(kodi-addon-sharedlibrary_API_LEVEL=${ADDON_API_LEVEL})
+set(kodi-addon-sharedlibrary_VERSION ${ADDON_API_VERSION})
+
+add_definitions(-DUSE_DEMUX)
+add_definitions(-DADDON_API_LEVEL=${ADDON_API_LEVEL})
+
+list(APPEND LIB_SOURCES InterProcess.cpp
+                        AddonLib.cpp
+                        ErrorCodeNames.cpp
+                        addon/AddonLib_Addon_General.cpp
+                        addon/AddonLib_Addon_Network.cpp
+                        addon/AddonLib_Addon_SoundPlay.cpp
+                        addon/AddonLib_Addon_VFSUtils.cpp
+                        audioengine/AddonLib_AudioEngine_General.cpp
+                        audioengine/AddonLib_AudioEngine_Stream.cpp
+                        gui/AddonLib_GUI_General.cpp
+                        gui/AddonLib_GUI_ControlButton.cpp
+                        gui/AddonLib_GUI_ControlEdit.cpp
+                        gui/AddonLib_GUI_ControlFadeLabel.cpp
+                        gui/AddonLib_GUI_ControlImage.cpp
+                        gui/AddonLib_GUI_ControlLabel.cpp
+                        gui/AddonLib_GUI_ControlProgress.cpp
+                        gui/AddonLib_GUI_ControlRadioButton.cpp
+                        gui/AddonLib_GUI_ControlRendering.cpp
+                        gui/AddonLib_GUI_ControlSettingsSlider.cpp
+                        gui/AddonLib_GUI_ControlSlider.cpp
+                        gui/AddonLib_GUI_ControlSpin.cpp
+                        gui/AddonLib_GUI_ControlTextBox.cpp
+                        gui/AddonLib_GUI_DialogContextMenu.cpp
+                        gui/AddonLib_GUI_DialogExtendedProgress.cpp
+                        gui/AddonLib_GUI_DialogFileBrowser.cpp
+                        gui/AddonLib_GUI_DialogKeyboard.cpp
+                        gui/AddonLib_GUI_DialogNumeric.cpp
+                        gui/AddonLib_GUI_DialogOK.cpp
+                        gui/AddonLib_GUI_DialogProgress.cpp
+                        gui/AddonLib_GUI_DialogSelect.cpp
+                        gui/AddonLib_GUI_DialogTextViewer.cpp
+                        gui/AddonLib_GUI_DialogYesNo.cpp
+                        gui/AddonLib_GUI_ListItem.cpp
+                        gui/AddonLib_GUI_Window.cpp
+                        inputstream/AddonLib_InputStream.cpp
+                        peripheral/AddonLib_Peripheral.cpp
+                        player/AddonLib_Player_InfoTagMusic.cpp
+                        player/AddonLib_Player_InfoTagVideo.cpp
+                        player/AddonLib_Player_Player.cpp
+                        player/AddonLib_Player_PlayList.cpp
+                        pvr/AddonLib_PVR_General.cpp
+                        pvr/AddonLib_PVR_Stream.cpp
+                        pvr/AddonLib_PVR_Transfer.cpp
+                        pvr/AddonLib_PVR_Trigger.cpp)
+
+if(WIN32)
+  list(APPEND DEPLIBS ws2_32)
+  list(APPEND LIB_SOURCES dlfcn-win32.cpp)
+else()
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC -std=c++11")
+endif()
+
+if(BUILD_KODI_ADDON)
+  list(APPEND INCLUDES ${KODI_INCLUDE_DIR})
+else()
+  list(APPEND INCLUDES ../../../../../
+                       ../../../../../cores/VideoPlayer/DVDDemuxers)
+endif()
+
+include_directories(${INCLUDES}
+                    ../../../include/
+                    .)
+
+add_library(kodi.addon.sharedlibrary.api${ADDON_API_LEVEL} STATIC ${LIB_SOURCES})
+target_link_libraries(kodi.addon.sharedlibrary.api${ADDON_API_LEVEL} ${DEPLIBS})
+set_target_properties(kodi.addon.sharedlibrary.api${ADDON_API_LEVEL} PROPERTIES OUTPUT_NAME kodi.addon.sharedlibrary.api${ADDON_API_LEVEL})
+
+install(TARGETS kodi.addon.sharedlibrary.api${ADDON_API_LEVEL} DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+# Set this way for compatibility to old configure system of kodi
+set(prefix ${CMAKE_INSTALL_PREFIX})
+set(exec_prefix ${CMAKE_INSTALL_PREFIX})
+set(libdir ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR})
+set(includedir ${CMAKE_INSTALL_PREFIX}/include)
+set(CXX ${CMAKE_CXX_COMPILER} ${CXX_STD0X_FLAGS})
+set(CC ${CMAKE_C_COMPILER} ${C_STD99_FLAGS})
+set(CXXFLAGS ${CMAKE_CXX_FLAGS})
+
+IF(NOT WIN32)
+  configure_file(kodi-addon-sharedlibrary-api2.pc.in ${CMAKE_BINARY_DIR}/kodi-addon-sharedlibrary-api2.pc @ONLY)
+  install(FILES ${CMAKE_BINARY_DIR}/kodi-addon-sharedlibrary-api2.pc
+          DESTINATION ${CMAKE_INSTALL_LIBDIR_NOARCH}/pkgconfig)
+ENDIF(NOT WIN32)
+
+# config mode
+configure_file (kodi-addon-sharedlibrary-api2-config.cmake.in
+                ${CMAKE_BINARY_DIR}/kodi-addon-sharedlibrary-api2-config.cmake @ONLY)
+install(FILES ${CMAKE_BINARY_DIR}/kodi-addon-sharedlibrary-api2-config.cmake
+        DESTINATION ${CMAKE_INSTALL_LIBDIR_NOARCH}/kodi)
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/ErrorCodeNames.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/ErrorCodeNames.cpp
new file mode 100644
index 0000000000..362529bdf3
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/ErrorCodeNames.cpp
@@ -0,0 +1,74 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include "ErrorCodeNames.h"
+#include KITINCLUDE(ADDON_API_LEVEL, .internal/AddonLib_internal.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+extern "C"
+{
+
+/*!
+ * @brief Last error code.
+ */
+uint32_t KODI_API_lasterror = API_SUCCESS;
+
+const KODI_API_ErrorTranslator errorTranslator[API_ERR_LASTCODE] =
+{
+  { API_SUCCESS,          "Successful return code" },
+  { API_ERR_BUFFER,       "Invalid buffer pointer" },
+  { API_ERR_COUNT,        "Invalid count argument" },
+  { API_ERR_TYPE,         "Invalid datatype argument" },
+  { API_ERR_TAG,          "Invalid tag argument" },
+  { API_ERR_COMM,         "Invalid communicator" },
+  { API_ERR_RANK,         "Invalid rank" },
+  { API_ERR_ROOT,         "Invalid root" },
+  { API_ERR_GROUP,        "Null group passed to function" },
+  { API_ERR_OP,           "Invalid operation" },
+  { API_ERR_TOPOLOGY,     "Invalid topology" },
+  { API_ERR_DIMS,         "Illegal dimension argument" },
+  { API_ERR_ARG,          "Invalid argument" },
+  { API_ERR_UNKNOWN,      "Unknown error" },
+  { API_ERR_TRUNCATE,     "message truncated on receive" },
+  { API_ERR_OTHER,        "Other error; use Error_string" },
+  { API_ERR_INTERN,       "internal error code" },
+  { API_ERR_IN_STATUS,    "Look in status for error value" },
+  { API_ERR_PENDING,      "Pending request" },
+  { API_ERR_REQUEST,      "illegal API_request handle" },
+  { API_ERR_CONNECTION,   "Failed to connect"},
+  { API_ERR_VALUE_NOT_AVAILABLE, "Requested value not available" }
+};
+
+const char* KodiAPI_ErrorCodeToString(uint32_t code)
+{
+  if (code < API_ERR_LASTCODE)
+    return errorTranslator[code].errorName;
+  else
+    return "Invalid Error code!";
+}
+
+} /* extern "C" */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/ErrorCodeNames.h b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/ErrorCodeNames.h
new file mode 100644
index 0000000000..e7e5c01039
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/ErrorCodeNames.h
@@ -0,0 +1,38 @@
+#pragma once
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <stdint.h>
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+extern "C"
+{
+
+extern uint32_t KODI_API_lasterror;
+
+const char* KodiAPI_ErrorCodeToString(uint32_t code);
+
+} /* extern "C" */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/InterProcess.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/InterProcess.cpp
new file mode 100644
index 0000000000..b81a862035
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/InterProcess.cpp
@@ -0,0 +1,114 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+
+#include <stdio.h>
+
+#ifdef _WIN32                   // windows
+  #ifndef _SSIZE_T_DEFINED
+    typedef intptr_t ssize_t;
+    #define _SSIZE_T_DEFINED
+  #endif // !_SSIZE_T_DEFINED
+  #include "dlfcn-win32.h"
+#else
+  #include <dlfcn.h>            // linux+osx
+#endif
+
+extern "C"
+{
+
+CKODIAddon_InterProcess g_interProcess;
+
+CKODIAddon_InterProcess::CKODIAddon_InterProcess()
+  : m_Handle(NULL),
+    m_Callbacks(NULL),
+    m_libKODI_addon(NULL)
+{
+
+}
+
+CKODIAddon_InterProcess::~CKODIAddon_InterProcess()
+{
+  Finalize();
+}
+
+//-- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - --
+
+int CKODIAddon_InterProcess::InitLibAddon(void* hdl)
+{
+  m_Handle = static_cast<ADDON::AddonCB*>(hdl);
+
+  m_libKODI_addon = dlopen(NULL, RTLD_LAZY);
+  if (m_libKODI_addon == NULL)
+  {
+    fprintf(stderr, "Unable to load %s\n", dlerror());
+    KODI_API_lasterror = API_ERR_OP;
+    return KODI_API_lasterror;
+  }
+
+  KODI_register = (_register_level*)
+    dlsym(m_libKODI_addon, "AddOnLib_Register");
+  if (KODI_register == NULL)
+  {
+    fprintf(stderr, "Unable to assign function %s\n", dlerror());
+    KODI_API_lasterror = API_ERR_CONNECTION;
+    return KODI_API_lasterror;
+  }
+
+  KODI_unregister = (_unregister_me*)
+    dlsym(m_libKODI_addon, "AddOnLib_UnRegister");
+  if (KODI_unregister == NULL)
+  {
+    fprintf(stderr, "Unable to assign function %s\n", dlerror());
+    KODI_API_lasterror = API_ERR_CONNECTION;
+    return KODI_API_lasterror;
+  }
+
+  m_Callbacks = KODI_register(m_Handle, 3);
+  if (m_Callbacks == NULL)
+  {
+    KODI_API_lasterror = API_ERR_BUFFER;
+    return KODI_API_lasterror;
+  }
+
+  KODI_API_lasterror = API_SUCCESS;
+  return KODI_API_lasterror;
+}
+
+int CKODIAddon_InterProcess::Finalize()
+{
+  if (m_libKODI_addon)
+  {
+    KODI_unregister(m_Handle, m_Callbacks);
+    dlclose(m_libKODI_addon);
+    m_libKODI_addon = NULL;
+  }
+
+  KODI_API_lasterror = API_SUCCESS;
+  return KODI_API_lasterror;
+}
+
+void CKODIAddon_InterProcess::Log(const addon_log loglevel, const char* string)
+{
+  m_Callbacks->addon_log_msg(m_Handle, loglevel, string);
+}
+
+} /* extern "C" */
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/InterProcess.h b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/InterProcess.h
new file mode 100644
index 0000000000..cb5103e535
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/InterProcess.h
@@ -0,0 +1,83 @@
+#pragma once
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "../version.h"
+#include "kodi/api2/definitions.hpp"
+
+#include KITINCLUDE(ADDON_API_LEVEL, AddonLib.hpp)
+#include KITINCLUDE(ADDON_API_LEVEL, .internal/AddonLib_internal.hpp)
+
+#include <stdlib.h>
+#include <string>
+
+#ifdef TARGET_WINDOWS
+#include <windows.h>
+#else
+#ifndef __cdecl
+#define __cdecl
+#endif
+#ifndef __declspec
+#define __declspec(X)
+#endif
+#endif
+
+extern "C"
+{
+
+  using namespace API_NAMESPACE_NAME::KodiAPI;
+
+  namespace ADDON
+  {
+    typedef struct AddonCB
+    {
+      const char* libBasePath;  ///< Never, never change this!!!
+      void*       addonData;
+    } AddonCB;
+  }
+
+  class CKODIAddon_InterProcess
+  {
+  public:
+    CKODIAddon_InterProcess();
+    virtual ~CKODIAddon_InterProcess();
+
+    int InitLibAddon(void* hdl);
+    int Finalize();
+    void Log(const addon_log loglevel, const char* string);
+
+    ADDON::AddonCB* m_Handle;
+    CB_AddOnLib*    m_Callbacks;
+
+  protected:
+    _register_level*  KODI_register;
+    _unregister_me*   KODI_unregister;
+
+  private:
+    void* m_libKODI_addon;
+    struct cb_array
+    {
+      const char* libPath;
+    };
+  };
+
+  extern CKODIAddon_InterProcess g_interProcess;
+
+} /* extern "C" */
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/Makefile b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/Makefile
new file mode 100644
index 0000000000..13d571bbbc
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/Makefile
@@ -0,0 +1,80 @@
+# WARNING: This Makefile is only be used on Kodi's own build. If you use it
+# independent is cmake needed for creation!
+#
+
+### The archiver options:
+
+AR       ?= ar
+ARFLAGS  ?= ru
+
+INCLUDES=-I. \
+         -I../../../../../ \
+         -I../../../../../cores/VideoPlayer/DVDDemuxers \
+         -I../../../include/
+
+DEFINES+=
+CXXFLAGS=-fPIC -std=c++11
+LIBNAME=libkodi.addon.sharedlibrary.api2.a
+
+### The object files (add further files here):
+
+OBJS=InterProcess.o \
+     AddonLib.o \
+     ErrorCodeNames.o \
+     addon/AddonLib_Addon_General.o \
+     addon/AddonLib_Addon_Network.o \
+     addon/AddonLib_Addon_SoundPlay.o \
+     addon/AddonLib_Addon_VFSUtils.o \
+     audioengine/AddonLib_AudioEngine_General.o \
+     audioengine/AddonLib_AudioEngine_Stream.o \
+     gui/AddonLib_GUI_General.o \
+     gui/AddonLib_GUI_ControlButton.o \
+     gui/AddonLib_GUI_ControlEdit.o \
+     gui/AddonLib_GUI_ControlFadeLabel.o \
+     gui/AddonLib_GUI_ControlImage.o \
+     gui/AddonLib_GUI_ControlLabel.o \
+     gui/AddonLib_GUI_ControlProgress.o \
+     gui/AddonLib_GUI_ControlRadioButton.o \
+     gui/AddonLib_GUI_ControlRendering.o \
+     gui/AddonLib_GUI_ControlSettingsSlider.o \
+     gui/AddonLib_GUI_ControlSlider.o \
+     gui/AddonLib_GUI_ControlSpin.o \
+     gui/AddonLib_GUI_ControlTextBox.o \
+     gui/AddonLib_GUI_DialogExtendedProgress.o \
+     gui/AddonLib_GUI_DialogFileBrowser.o \
+     gui/AddonLib_GUI_DialogKeyboard.o \
+     gui/AddonLib_GUI_DialogNumeric.o \
+     gui/AddonLib_GUI_DialogOK.o \
+     gui/AddonLib_GUI_DialogProgress.o \
+     gui/AddonLib_GUI_DialogSelect.o \
+     gui/AddonLib_GUI_DialogTextViewer.o \
+     gui/AddonLib_GUI_DialogYesNo.o \
+     gui/AddonLib_GUI_ListItem.o \
+     gui/AddonLib_GUI_Window.o \
+     inputstream/AddonLib_InputStream.o \
+     peripheral/AddonLib_Peripheral.o \
+     player/AddonLib_Player_InfoTagMusic.o \
+     player/AddonLib_Player_InfoTagVideo.o \
+     player/AddonLib_Player_Player.o \
+     player/AddonLib_Player_PlayList.o \
+     pvr/AddonLib_PVR_General.o \
+     pvr/AddonLib_PVR_Stream.o \
+     pvr/AddonLib_PVR_Transfer.o \
+     pvr/AddonLib_PVR_Trigger.o
+
+### Implicit rules:
+
+%.o: %.cpp
+	$(CXX) $(CXXFLAGS) -c $(DEFINES) $(INCLUDES) $<
+
+all: $(LIBNAME)
+
+### Targets:
+
+$(LIBNAME): $(OBJS)
+	$(AR) $(ARFLAGS) $@ $(OBJS)
+
+CLEAN_FILES = \
+	$(LIBNAME) \
+
+include ../../../../../../Makefile.include
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/addon/AddonLib_Addon_General.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/addon/AddonLib_Addon_General.cpp
new file mode 100644
index 0000000000..e290279c34
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/addon/AddonLib_Addon_General.cpp
@@ -0,0 +1,373 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, addon/General.hpp)
+
+#include <string>
+#include <cstring>
+#include <stdarg.h>
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace AddOn
+{
+namespace General
+{
+
+  bool GetSettingString(
+      const std::string& settingName,
+      std::string&       settingValue,
+      bool               global)
+  {
+    char * buffer = (char*) malloc(1024);
+    buffer[0] = 0; /* Set the end of string */
+    bool ret = g_interProcess.m_Callbacks->General.get_setting(g_interProcess.m_Handle, settingName.c_str(), buffer, global);
+    if (ret)
+      settingValue = buffer;
+    free(buffer);
+    return ret;
+  }
+
+  bool GetSettingInt(
+      const std::string& settingName,
+      int&               settingValue,
+      bool               global)
+  {
+    return g_interProcess.m_Callbacks->General.get_setting(g_interProcess.m_Handle, settingName.c_str(), &settingValue, global);
+  }
+
+  bool GetSettingBoolean(
+      const std::string& settingName,
+      bool&              settingValue,
+      bool               global)
+  {
+    return g_interProcess.m_Callbacks->General.get_setting(g_interProcess.m_Handle, settingName.c_str(), &settingValue, global);
+  }
+
+  bool GetSettingFloat(
+      const std::string& settingName,
+      float&             settingValue,
+      bool               global)
+  {
+    return g_interProcess.m_Callbacks->General.get_setting(g_interProcess.m_Handle, settingName.c_str(), &settingValue, global);
+  }
+
+  void OpenSettings()
+  {
+    g_interProcess.m_Callbacks->General.open_settings_dialog(g_interProcess.m_Handle);
+  }
+
+  void QueueFormattedNotification(const queue_msg type, const char *format, ... )
+  {
+    va_list args;
+    char buffer[16384];
+    va_start(args, format);
+    vsprintf(buffer, format, args);
+    va_end(args);
+    g_interProcess.m_Callbacks->General.queue_notification(g_interProcess.m_Handle, type, buffer);
+  }
+
+  void QueueNotification(
+      const queue_msg  type,
+      const std::string& aCaption,
+      const std::string& aDescription,
+      unsigned int       displayTime,
+      bool               withSound,
+      unsigned int       messageTime)
+  {
+    g_interProcess.m_Callbacks->General.queue_notification_from_type(g_interProcess.m_Handle,
+                                      type, aCaption.c_str(), aDescription.c_str(),
+                                      displayTime, withSound, messageTime);
+  }
+
+  void QueueNotification(
+    const std::string& aCaption,
+    const std::string& aDescription)
+  {
+    g_interProcess.m_Callbacks->General.queue_notification_with_image(g_interProcess.m_Handle, "",
+                                      aCaption.c_str(), aDescription.c_str(),
+                                      5000, false, 1000);
+  }
+
+  void QueueNotification(
+      const std::string& aImageFile,
+      const std::string& aCaption,
+      const std::string& aDescription,
+      unsigned int       displayTime,
+      bool               withSound,
+      unsigned int       messageTime)
+  {
+    g_interProcess.m_Callbacks->General.queue_notification_with_image(g_interProcess.m_Handle, aImageFile.c_str(),
+                                      aCaption.c_str(), aDescription.c_str(),
+                                      displayTime, withSound, messageTime);
+  }
+
+  void GetMD5(const std::string& text, std::string& md5)
+  {
+    char* md5ret = (char*)malloc(40*sizeof(char)); // md5 size normally 32 bytes
+    g_interProcess.m_Callbacks->General.get_md5(text.c_str(), *md5ret);
+    md5 = md5ret;
+    free(md5ret);
+  }
+
+  bool UnknownToUTF8(
+      const std::string&  stringSrc,
+      std::string&        utf8StringDst,
+      bool                failOnBadChar)
+  {
+    bool ret = false;
+    char* retString = g_interProcess.m_Callbacks->General.unknown_to_utf8(g_interProcess.m_Handle, stringSrc.c_str(), ret, failOnBadChar);
+    if (retString != nullptr)
+    {
+      if (ret)
+        utf8StringDst = retString;
+      g_interProcess.m_Callbacks->free_string(g_interProcess.m_Handle, retString);
+    }
+    return ret;
+  }
+
+  std::string GetLocalizedString(uint32_t labelId, const std::string& strDefault)
+  {
+    std::string strReturn = strDefault;
+    char* strMsg = g_interProcess.m_Callbacks->General.get_localized_string(g_interProcess.m_Handle, labelId);
+    if (strMsg != nullptr)
+    {
+      if (std::strlen(strMsg))
+        strReturn = strMsg;
+      g_interProcess.m_Callbacks->free_string(g_interProcess.m_Handle, strMsg);
+    }
+    return strReturn;
+  }
+
+  std::string GetLanguage(lang_formats format, bool region)
+  {
+    std::string language;
+    language.resize(256);
+    unsigned int size = (unsigned int)language.capacity();
+    g_interProcess.m_Callbacks->General.get_language(g_interProcess.m_Handle, language[0], size, format, region);
+    language.resize(size);
+    language.shrink_to_fit();
+    return language;
+  }
+
+  std::string GetDVDMenuLanguage()
+  {
+    std::string language;
+    language.resize(16);
+    unsigned int size = (unsigned int)language.capacity();
+    g_interProcess.m_Callbacks->General.get_dvd_menu_language(g_interProcess.m_Handle, language[0], size);
+    language.resize(size);
+    language.shrink_to_fit();
+    return language;
+  }
+
+  bool StartServer(eservers typ, bool start, bool wait)
+  {
+    return g_interProcess.m_Callbacks->General.start_server(g_interProcess.m_Handle, (int)typ, start, wait);
+  }
+
+  void AudioSuspend()
+  {
+    g_interProcess.m_Callbacks->General.audio_suspend(g_interProcess.m_Handle);
+  }
+
+  void AudioResume()
+  {
+    g_interProcess.m_Callbacks->General.audio_resume(g_interProcess.m_Handle);
+  }
+
+  float GetVolume(bool percentage)
+  {
+    return g_interProcess.m_Callbacks->General.get_volume(g_interProcess.m_Handle, percentage);
+  }
+
+  void SetVolume(float value, bool isPercentage)
+  {
+    g_interProcess.m_Callbacks->General.set_volume(g_interProcess.m_Handle, value, isPercentage);
+  }
+
+  bool IsMuted()
+  {
+    return g_interProcess.m_Callbacks->General.is_muted(g_interProcess.m_Handle);
+  }
+
+  void ToggleMute()
+  {
+    g_interProcess.m_Callbacks->General.toggle_mute(g_interProcess.m_Handle);
+  }
+
+  void SetMute(bool mute)
+  {
+    if (g_interProcess.m_Callbacks->General.is_muted(g_interProcess.m_Handle) != mute)
+      g_interProcess.m_Callbacks->General.toggle_mute(g_interProcess.m_Handle);
+  }
+
+  dvd_state GetOpticalDriveState()
+  {
+    return (dvd_state)g_interProcess.m_Callbacks->General.get_optical_state(g_interProcess.m_Handle);
+  }
+
+  bool EjectOpticalDrive()
+  {
+    return g_interProcess.m_Callbacks->General.eject_optical_drive(g_interProcess.m_Handle);
+  }
+
+  void KodiVersion(kodi_version& version)
+  {
+    char* compile_name = nullptr;
+    char* revision     = nullptr;
+    char* tag          = nullptr;
+    char* tag_revision = nullptr;
+
+    g_interProcess.m_Callbacks->General.kodi_version(g_interProcess.m_Handle, compile_name, version.major, version.minor, revision, tag, tag_revision);
+    if (compile_name != nullptr)
+    {
+      version.compile_name  = compile_name;
+      g_interProcess.m_Callbacks->free_string(g_interProcess.m_Handle, compile_name);
+    }
+    if (revision != nullptr)
+    {
+      version.revision = revision;
+      g_interProcess.m_Callbacks->free_string(g_interProcess.m_Handle, revision);
+    }
+    if (tag != nullptr)
+    {
+      version.tag = tag;
+      g_interProcess.m_Callbacks->free_string(g_interProcess.m_Handle, tag);
+    }
+    if (tag_revision != nullptr)
+    {
+      version.tag_revision = tag_revision;
+      g_interProcess.m_Callbacks->free_string(g_interProcess.m_Handle, tag_revision);
+    }
+  }
+
+  void KodiQuit()
+  {
+    g_interProcess.m_Callbacks->General.kodi_quit(g_interProcess.m_Handle);
+  }
+
+  void HTPCShutdown()
+  {
+    g_interProcess.m_Callbacks->General.htpc_shutdown(g_interProcess.m_Handle);
+  }
+
+  void HTPCRestart()
+  {
+    g_interProcess.m_Callbacks->General.htpc_restart(g_interProcess.m_Handle);
+  }
+
+  void ExecuteScript(const std::string& script)
+  {
+    g_interProcess.m_Callbacks->General.execute_script(g_interProcess.m_Handle, script.c_str());
+  }
+
+  void ExecuteBuiltin(const std::string& function, bool wait)
+  {
+    g_interProcess.m_Callbacks->General.execute_builtin(g_interProcess.m_Handle, function.c_str(), wait);
+  }
+
+  std::string ExecuteJSONRPC(const std::string& jsonrpccommand)
+  {
+    std::string strReturn;
+    char* strMsg = g_interProcess.m_Callbacks->General.execute_jsonrpc(g_interProcess.m_Handle, jsonrpccommand.c_str());
+    if (strMsg != nullptr)
+    {
+      if (std::strlen(strMsg))
+        strReturn = strMsg;
+      g_interProcess.m_Callbacks->free_string(g_interProcess.m_Handle, strMsg);
+    }
+    return strReturn;
+  }
+
+  std::string GetRegion(const std::string& id)
+  {
+    std::string strReturn;
+    char* strMsg = g_interProcess.m_Callbacks->General.get_region(g_interProcess.m_Handle, id.c_str());
+    if (strMsg != nullptr)
+    {
+      if (std::strlen(strMsg))
+        strReturn = strMsg;
+      g_interProcess.m_Callbacks->free_string(g_interProcess.m_Handle, strMsg);
+    }
+    return strReturn;
+  }
+
+  long GetFreeMem()
+  {
+    return g_interProcess.m_Callbacks->General.get_free_mem(g_interProcess.m_Handle);
+  }
+
+  int GetGlobalIdleTime()
+  {
+    return g_interProcess.m_Callbacks->General.get_global_idle_time(g_interProcess.m_Handle);
+  }
+
+  std::string GetAddonInfo(const std::string& id)
+  {
+    std::string strReturn;
+    char* strMsg = g_interProcess.m_Callbacks->General.get_addon_info(g_interProcess.m_Handle, id.c_str());
+    if (strMsg != nullptr)
+    {
+      if (std::strlen(strMsg))
+        strReturn = strMsg;
+      g_interProcess.m_Callbacks->free_string(g_interProcess.m_Handle, strMsg);
+    }
+    return strReturn;
+  }
+
+  std::string TranslatePath(const std::string& path)
+  {
+    std::string strReturn;
+    char* strMsg = g_interProcess.m_Callbacks->General.translate_path(g_interProcess.m_Handle, path.c_str());
+    if (strMsg != nullptr)
+    {
+      if (std::strlen(strMsg))
+        strReturn = strMsg;
+      g_interProcess.m_Callbacks->free_string(g_interProcess.m_Handle, strMsg);
+    }
+    return strReturn;
+  }
+
+  std::string TranslateAddonStatus(ADDON_STATUS status)
+  {
+    switch (status)
+    {
+      case ADDON_STATUS_OK:                 return "OK";
+      case ADDON_STATUS_LOST_CONNECTION:    return "Lost connection";
+      case ADDON_STATUS_NEED_RESTART:       return "Needs restart";
+      case ADDON_STATUS_NEED_SETTINGS:      return "Needs settngs";
+      case ADDON_STATUS_UNKNOWN:            return "Unknown";
+      case ADDON_STATUS_NEED_SAVEDSETTINGS: return "Needs saved settings";
+      case ADDON_STATUS_PERMANENT_FAILURE:  return "Permanent failure";
+      default:
+        break;
+    }
+    return "";
+  }
+
+} /* namespace General */
+} /* namespace AddOn */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/addon/AddonLib_Addon_Network.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/addon/AddonLib_Addon_Network.cpp
new file mode 100644
index 0000000000..7b7da73200
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/addon/AddonLib_Addon_Network.cpp
@@ -0,0 +1,79 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+
+#include <string>
+#include <stdarg.h>
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace AddOn
+{
+namespace Network
+{
+
+  bool WakeOnLan(const std::string& mac)
+  {
+    return g_interProcess.m_Callbacks->Network.wake_on_lan(g_interProcess.m_Handle, mac.c_str());
+  }
+
+  std::string GetIPAddress()
+  {
+    std::string ip;
+    ip.resize(32);
+    unsigned int size = (unsigned int)ip.capacity();
+    g_interProcess.m_Callbacks->Network.get_ip_address(g_interProcess.m_Handle, ip[0], size);
+    ip.resize(size);
+    ip.shrink_to_fit();
+    return ip;
+  }
+
+  std::string URLEncode(const std::string& url)
+  {
+    std::string retString;
+    char* string = g_interProcess.m_Callbacks->Network.url_encode(g_interProcess.m_Handle, url.c_str());
+    if (string != nullptr)
+    {
+      retString = string;
+      g_interProcess.m_Callbacks->free_string(g_interProcess.m_Handle, string);
+    }
+    return retString;
+  }
+
+  bool DNSLookup(const std::string& strHostName, std::string& strIpAddress)
+  {
+    bool ret = false;
+    char* ipAddress = g_interProcess.m_Callbacks->Network.dns_lookup(g_interProcess.m_Handle, strHostName.c_str(), ret);
+    if (ipAddress != nullptr)
+    {
+      strIpAddress = ipAddress;
+      g_interProcess.m_Callbacks->free_string(g_interProcess.m_Handle, ipAddress);
+    }
+    return ret;
+  }
+
+} /* namespace KodiAPI_Codec */
+} /* namespace AddOn */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/addon/AddonLib_Addon_SoundPlay.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/addon/AddonLib_Addon_SoundPlay.cpp
new file mode 100644
index 0000000000..5ae3ba69d0
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/addon/AddonLib_Addon_SoundPlay.cpp
@@ -0,0 +1,86 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, addon/SoundPlay.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace AddOn
+{
+
+  CSoundPlay::CSoundPlay(const std::string& filename)
+   : m_PlayHandle(nullptr)
+  {
+    m_PlayHandle = g_interProcess.m_Callbacks->Audio.soundplay_get_handle(g_interProcess.m_Handle, filename.c_str());
+    if (!m_PlayHandle)
+      fprintf(stderr, "libKODI_addon-ERROR: CSoundPlay can't get callback table from KODI !!!\n");
+  }
+
+  CSoundPlay::~CSoundPlay()
+  {
+    if (m_PlayHandle)
+      g_interProcess.m_Callbacks->Audio.soundplay_release_handle(g_interProcess.m_Handle, m_PlayHandle);
+  }
+
+  void CSoundPlay::Play()
+  {
+    if (m_PlayHandle)
+      g_interProcess.m_Callbacks->Audio.soundplay_play(g_interProcess.m_Handle, m_PlayHandle);
+  }
+
+  void CSoundPlay::Stop()
+  {
+    if (m_PlayHandle)
+      g_interProcess.m_Callbacks->Audio.soundplay_stop(g_interProcess.m_Handle, m_PlayHandle);
+  }
+
+  void CSoundPlay::SetChannel(audio_channel channel)
+  {
+    if (m_PlayHandle)
+      g_interProcess.m_Callbacks->Audio.soundplay_set_channel(g_interProcess.m_Handle, m_PlayHandle, channel);
+  }
+
+  audio_channel CSoundPlay::GetChannel()
+  {
+    if (!m_PlayHandle)
+      return AUDIO_CH_INVALID;
+    return (audio_channel)g_interProcess.m_Callbacks->Audio.soundplay_get_channel(g_interProcess.m_Handle, m_PlayHandle);
+  }
+
+  void CSoundPlay::SetVolume(float volume)
+  {
+    if (m_PlayHandle)
+      g_interProcess.m_Callbacks->Audio.soundplay_set_volume(g_interProcess.m_Handle, m_PlayHandle, volume);
+  }
+
+  float CSoundPlay::GetVolume()
+  {
+    if (!m_PlayHandle)
+      return 0.0f;
+    return g_interProcess.m_Callbacks->Audio.soundplay_get_volume(g_interProcess.m_Handle, m_PlayHandle);
+  }
+
+} /* namespace AddOn */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/addon/AddonLib_Addon_VFSUtils.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/addon/AddonLib_Addon_VFSUtils.cpp
new file mode 100644
index 0000000000..afe6bddc96
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/addon/AddonLib_Addon_VFSUtils.cpp
@@ -0,0 +1,358 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, addon/VFSUtils.hpp)
+
+#include <cstring>
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace AddOn
+{
+
+  CVFSDirEntry::CVFSDirEntry(
+        const std::string& label,
+        const std::string& path,
+        bool               bFolder,
+        int64_t            size)
+    : m_label(label),
+      m_path(path),
+      m_bFolder(bFolder),
+      m_size(size)
+  {
+  }
+
+  CVFSDirEntry::CVFSDirEntry(const VFSDirEntry& dirEntry)
+    : m_label(dirEntry.label ? dirEntry.label : ""),
+      m_path(dirEntry.path   ? dirEntry.path  : ""),
+      m_bFolder(dirEntry.folder),
+      m_size(dirEntry.size)
+  {
+  }
+
+  const std::string& CVFSDirEntry::Label(void) const
+  {
+    return m_label;
+  }
+
+  const std::string& CVFSDirEntry::Path(void) const
+  {
+    return m_path;
+  }
+
+  bool CVFSDirEntry::IsFolder(void) const
+  {
+    return m_bFolder;
+  }
+
+  int64_t CVFSDirEntry::Size(void) const
+  {
+    return m_size;
+  }
+
+  void CVFSDirEntry::SetLabel(const std::string& label)
+  {
+    m_label = label;
+  }
+
+  void CVFSDirEntry::SetPath(const std::string& path)
+  {
+    m_path = path;
+  }
+
+  void CVFSDirEntry::SetFolder(bool bFolder)
+  {
+    m_bFolder = bFolder;
+  }
+
+  void CVFSDirEntry::SetSize(int64_t size)
+  {
+    m_size = size;
+  }
+  //----------------------------------------------------------------------------
+
+
+  //============================================================================
+  CVFSFile::CVFSFile()
+   : m_pFile(nullptr)
+  {
+
+  }
+
+  CVFSFile::~CVFSFile()
+  {
+    Close();
+  }
+
+  bool CVFSFile::OpenFile(const std::string& strFileName, unsigned int flags)
+  {
+    Close();
+    m_pFile = g_interProcess.m_Callbacks->File.open_file(g_interProcess.m_Handle, strFileName.c_str(), flags);
+    return m_pFile != nullptr;
+  }
+
+  bool CVFSFile::OpenFileForWrite(const std::string& strFileName, bool bOverWrite)
+  {
+    Close();
+
+    // Try to open the file. If it fails, check if we need to create the directory first
+    // This way we avoid checking if the directory exists every time
+    m_pFile = g_interProcess.m_Callbacks->File.open_file_for_write(g_interProcess.m_Handle, strFileName.c_str(), bOverWrite);
+    if (!m_pFile)
+    {
+      std::string cacheDirectory = KodiAPI::AddOn::VFSUtils::GetDirectoryName(strFileName);
+      if (g_interProcess.m_Callbacks->Directory.directory_exists(g_interProcess.m_Handle, cacheDirectory.c_str()) ||
+          g_interProcess.m_Callbacks->Directory.create_directory(g_interProcess.m_Handle, cacheDirectory.c_str()))
+        m_pFile = g_interProcess.m_Callbacks->File.open_file_for_write(g_interProcess.m_Handle, strFileName.c_str(), bOverWrite);
+    }
+    return m_pFile != nullptr;
+  }
+
+  ssize_t CVFSFile::Read(void* lpBuf, size_t uiBufSize)
+  {
+    if (!m_pFile)
+      return 0;
+    return g_interProcess.m_Callbacks->File.read_file(g_interProcess.m_Handle, m_pFile, lpBuf, uiBufSize);
+  }
+
+  bool CVFSFile::ReadLine(std::string &strLine)
+  {
+    strLine.clear();
+    if (!m_pFile)
+      return false;
+    // TODO: Read 1024 chars into buffer. If file position advanced that many
+    // chars, we didn't hit a newline. Otherwise, if file position is 1 or 2
+    // past the number of bytes read, we read (and skipped) a newline sequence.
+    char buffer[1025];
+    if (g_interProcess.m_Callbacks->File.read_file_string(g_interProcess.m_Handle, m_pFile, buffer, sizeof(buffer)))
+    {
+      strLine = buffer;
+      return !strLine.empty();
+    }
+    return false;
+  }
+
+  ssize_t CVFSFile::Write(const void* lpBuf, size_t uiBufSize)
+  {
+    if (!m_pFile)
+      return 0;
+    return g_interProcess.m_Callbacks->File.write_file(g_interProcess.m_Handle, m_pFile, lpBuf, uiBufSize);
+  }
+
+  void CVFSFile::Flush()
+  {
+    if (!m_pFile)
+      return;
+    g_interProcess.m_Callbacks->File.flush_file(g_interProcess.m_Handle, m_pFile);
+  }
+
+  int64_t CVFSFile::Seek(int64_t iFilePosition, int iWhence)
+  {
+    if (!m_pFile)
+      return 0;
+    return g_interProcess.m_Callbacks->File.seek_file(g_interProcess.m_Handle, m_pFile, iFilePosition, iWhence);
+  }
+
+  int CVFSFile::Truncate(int64_t iSize)
+  {
+    if (!m_pFile)
+      return -1;
+    return g_interProcess.m_Callbacks->File.truncate_file(g_interProcess.m_Handle, m_pFile, iSize);
+  }
+
+  int64_t CVFSFile::GetPosition()
+  {
+    if (!m_pFile)
+      return -1;
+    return g_interProcess.m_Callbacks->File.get_file_position(g_interProcess.m_Handle, m_pFile);
+  }
+
+  int64_t CVFSFile::GetLength()
+  {
+    if (!m_pFile)
+      return 0;
+    return g_interProcess.m_Callbacks->File.get_file_length(g_interProcess.m_Handle, m_pFile);
+  }
+
+  void CVFSFile::Close()
+  {
+    if (!m_pFile)
+      return;
+    g_interProcess.m_Callbacks->File.close_file(g_interProcess.m_Handle, m_pFile);
+    m_pFile = nullptr;
+  }
+
+  int CVFSFile::GetChunkSize()
+  {
+    if (!m_pFile)
+      return 0;
+    return g_interProcess.m_Callbacks->File.get_file_chunk_size(g_interProcess.m_Handle, m_pFile);
+  }
+  //----------------------------------------------------------------------------
+
+
+  //============================================================================
+  namespace VFSUtils
+  {
+
+    bool CreateDirectory(const std::string& strPath)
+    {
+      return g_interProcess.m_Callbacks->Directory.create_directory(g_interProcess.m_Handle, strPath.c_str());
+    }
+
+    bool DirectoryExists(const std::string& strPath)
+    {
+      return g_interProcess.m_Callbacks->Directory.directory_exists(g_interProcess.m_Handle, strPath.c_str());
+    }
+
+    bool RemoveDirectory(const std::string& strPath)
+    {
+      return g_interProcess.m_Callbacks->Directory.remove_directory(g_interProcess.m_Handle, strPath.c_str());
+    }
+
+    bool GetDirectory(
+          const std::string&          path,
+          const std::string&          mask,
+          std::vector<CVFSDirEntry>&  items)
+    {
+      VFSDirEntry* dir_list  = nullptr;
+      unsigned int num_items = 0;
+      if (g_interProcess.m_Callbacks->VFS.get_directory(g_interProcess.m_Handle, path.c_str(), mask.c_str(), &dir_list, &num_items))
+      {
+        if (dir_list)
+        {
+          for (unsigned int i = 0; i < num_items; ++i)
+            items.push_back(CVFSDirEntry(dir_list[i]));
+
+          g_interProcess.m_Callbacks->VFS.free_directory(g_interProcess.m_Handle, dir_list, num_items);
+        }
+
+        return true;
+      }
+      return false;
+    }
+
+    std::string MakeLegalFileName(const std::string& strFileName)
+    {
+      std::string strReturn;
+      char* strLegalFileName = g_interProcess.m_Callbacks->File.make_legal_filename(g_interProcess.m_Handle, strFileName.c_str());
+      if (strLegalFileName != nullptr)
+      {
+        if (std::strlen(strLegalFileName))
+          strReturn = strLegalFileName;
+        g_interProcess.m_Callbacks->free_string(g_interProcess.m_Handle, strLegalFileName);
+      }
+      return strReturn;
+    }
+
+    std::string MakeLegalPath(const std::string& strPath)
+    {
+      std::string strReturn;
+      char* strLegalPath = g_interProcess.m_Callbacks->File.make_legal_path(g_interProcess.m_Handle, strPath.c_str());
+      if (strLegalPath != nullptr)
+      {
+        if (std::strlen(strLegalPath))
+          strReturn = strLegalPath;
+        g_interProcess.m_Callbacks->free_string(g_interProcess.m_Handle, strLegalPath);
+      }
+      return strReturn;
+    }
+
+    bool FileExists(const std::string& strFileName, bool bUseCache)
+    {
+      return g_interProcess.m_Callbacks->File.file_exists(g_interProcess.m_Handle, strFileName.c_str(), bUseCache);
+    }
+
+    int StatFile(const std::string& strFileName, struct __stat64* buffer)
+    {
+      return g_interProcess.m_Callbacks->File.stat_file(g_interProcess.m_Handle, strFileName.c_str(), buffer);
+    }
+
+    bool DeleteFile(const std::string& strFileName)
+    {
+      return g_interProcess.m_Callbacks->File.delete_file(g_interProcess.m_Handle, strFileName.c_str());
+    }
+
+    std::string GetFileMD5(const std::string& strPath)
+    {
+      std::string strReturn;
+      char* strMd5 = g_interProcess.m_Callbacks->File.get_file_md5(g_interProcess.m_Handle, strPath.c_str());
+      if (strMd5 != nullptr)
+      {
+        if (std::strlen(strMd5))
+          strReturn = strMd5;
+        g_interProcess.m_Callbacks->free_string(g_interProcess.m_Handle, strMd5);
+      }
+      return strReturn;
+    }
+
+    std::string GetCacheThumbName(const std::string& strFileName)
+    {
+      std::string strReturn;
+      char* strThumbName = g_interProcess.m_Callbacks->File.get_cache_thumb_name(g_interProcess.m_Handle, strFileName.c_str());
+      if (strThumbName != nullptr)
+      {
+        if (std::strlen(strThumbName))
+          strReturn = strThumbName;
+        g_interProcess.m_Callbacks->free_string(g_interProcess.m_Handle, strThumbName);
+      }
+      return strReturn;
+    }
+
+    unsigned int GetChunkSize(unsigned int chunk, unsigned int minimum)
+    {
+      if (chunk)
+        return chunk * ((minimum + chunk - 1) / chunk);
+      else
+        return minimum;
+    }
+
+    std::string GetFileName(const std::string& strFileNameAndPath)
+    {
+      /* find the last slash */
+      const size_t slash = strFileNameAndPath.find_last_of("/\\");
+      return strFileNameAndPath.substr(slash+1);
+    }
+
+    std::string GetDirectoryName(const std::string &strFilePath)
+    {
+      // Will from a full filename return the directory the file resides in.
+      // Keeps the final slash at end and possible |option=foo options.
+
+      size_t iPosSlash = strFilePath.find_last_of("/\\");
+      if (iPosSlash == std::string::npos)
+        return ""; // No slash, so no path (ignore any options)
+
+      size_t iPosBar = strFilePath.rfind('|');
+      if (iPosBar == std::string::npos)
+        return strFilePath.substr(0, iPosSlash + 1); // Only path
+
+      return strFilePath.substr(0, iPosSlash + 1) + strFilePath.substr(iPosBar); // Path + options
+    }
+
+  } /* namespace VFSUtils */
+
+} /* namespace AddOn */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/audioengine/AddonLib_AudioEngine_General.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/audioengine/AddonLib_AudioEngine_General.cpp
new file mode 100644
index 0000000000..695da0403f
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/audioengine/AddonLib_AudioEngine_General.cpp
@@ -0,0 +1,65 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, audioengine/General.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+
+namespace AudioEngine
+{
+namespace General
+{
+
+  void AddDSPMenuHook(AE_DSP_MENUHOOK* hook)
+  {
+    g_interProcess.m_Callbacks->AudioEngine.add_dsp_menu_hook(g_interProcess.m_Handle, hook);
+  }
+
+  void RemoveDSPMenuHook(AE_DSP_MENUHOOK* hook)
+  {
+    g_interProcess.m_Callbacks->AudioEngine.remove_dsp_menu_hook(g_interProcess.m_Handle, hook);
+  }
+  /*\_________________________________________________________________________
+  \*/
+  void RegisterDSPMode(AE_DSP_MODES::AE_DSP_MODE* mode)
+  {
+    g_interProcess.m_Callbacks->AudioEngine.register_dsp_mode(g_interProcess.m_Handle, mode);
+  }
+
+  void UnregisterDSPMode(AE_DSP_MODES::AE_DSP_MODE* mode)
+  {
+    g_interProcess.m_Callbacks->AudioEngine.unregister_dsp_Mode(g_interProcess.m_Handle, mode);
+  }
+  /*\_________________________________________________________________________
+  \*/
+  bool GetCurrentSinkFormat(AudioEngineFormat &SinkFormat)
+  {
+    return g_interProcess.m_Callbacks->AudioEngine.get_current_sink_format(g_interProcess.m_Handle, &SinkFormat);
+  }
+
+} /* namespace General */
+} /* namespace AudioEngine */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/audioengine/AddonLib_AudioEngine_Stream.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/audioengine/AddonLib_AudioEngine_Stream.cpp
new file mode 100644
index 0000000000..cb20cca702
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/audioengine/AddonLib_AudioEngine_Stream.cpp
@@ -0,0 +1,160 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, audioengine/Stream.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+
+namespace AudioEngine
+{
+
+  CStream::CStream(
+      AudioEngineFormat   Format,
+      unsigned int        Options)
+  {
+    m_StreamHandle = g_interProcess.m_Callbacks->AudioEngine.make_stream(g_interProcess.m_Handle, Format, Options);
+    if (!m_StreamHandle)
+      fprintf(stderr, "libKODI_audioengine-ERROR: make_stream failed!\n");
+    m_planes = g_interProcess.m_Callbacks->AudioEngineStream.AEStream_GetChannelCount(g_interProcess.m_Handle, m_StreamHandle);
+  }
+
+  CStream::~CStream()
+  {
+    g_interProcess.m_Callbacks->AudioEngine.free_stream(g_interProcess.m_Handle, m_StreamHandle);
+  }
+
+  unsigned int CStream::GetSpace()
+  {
+    return g_interProcess.m_Callbacks->AudioEngineStream.AEStream_GetSpace(g_interProcess.m_Handle, m_StreamHandle);
+  }
+
+  unsigned int CStream::AddData(uint8_t* const *Data, unsigned int Offset, unsigned int Frames)
+  {
+    return g_interProcess.m_Callbacks->AudioEngineStream.AEStream_AddData(g_interProcess.m_Handle, m_StreamHandle, Data, Offset, Frames);
+  }
+
+  double CStream::GetDelay()
+  {
+    return g_interProcess.m_Callbacks->AudioEngineStream.AEStream_GetDelay(g_interProcess.m_Handle, m_StreamHandle);
+  }
+
+  bool CStream::IsBuffering()
+  {
+    return g_interProcess.m_Callbacks->AudioEngineStream.AEStream_IsBuffering(g_interProcess.m_Handle, m_StreamHandle);
+  }
+
+  double CStream::GetCacheTime()
+  {
+    return g_interProcess.m_Callbacks->AudioEngineStream.AEStream_GetCacheTime(g_interProcess.m_Handle, m_StreamHandle);
+  }
+
+  double CStream::GetCacheTotal()
+  {
+    return g_interProcess.m_Callbacks->AudioEngineStream.AEStream_GetCacheTotal(g_interProcess.m_Handle, m_StreamHandle);
+  }
+
+  void CStream::Pause()
+  {
+    return g_interProcess.m_Callbacks->AudioEngineStream.AEStream_Pause(g_interProcess.m_Handle, m_StreamHandle);
+  }
+
+  void CStream::Resume()
+  {
+    return g_interProcess.m_Callbacks->AudioEngineStream.AEStream_Resume(g_interProcess.m_Handle, m_StreamHandle);
+  }
+
+  void CStream::Drain(bool Wait)
+  {
+    return g_interProcess.m_Callbacks->AudioEngineStream.AEStream_Drain(g_interProcess.m_Handle, m_StreamHandle, Wait);
+  }
+
+  bool CStream::IsDraining()
+  {
+    return g_interProcess.m_Callbacks->AudioEngineStream.AEStream_IsDraining(g_interProcess.m_Handle, m_StreamHandle);
+  }
+
+  bool CStream::IsDrained()
+  {
+    return g_interProcess.m_Callbacks->AudioEngineStream.AEStream_IsDrained(g_interProcess.m_Handle, m_StreamHandle);
+  }
+
+  void CStream::Flush()
+  {
+    return g_interProcess.m_Callbacks->AudioEngineStream.AEStream_Flush(g_interProcess.m_Handle, m_StreamHandle);
+  }
+
+  float CStream::GetVolume()
+  {
+    return g_interProcess.m_Callbacks->AudioEngineStream.AEStream_GetVolume(g_interProcess.m_Handle, m_StreamHandle);
+  }
+
+  void CStream::SetVolume(float Volume)
+  {
+    return g_interProcess.m_Callbacks->AudioEngineStream.AEStream_SetVolume(g_interProcess.m_Handle, m_StreamHandle, Volume);
+  }
+
+  float CStream::GetAmplification()
+  {
+    return g_interProcess.m_Callbacks->AudioEngineStream.AEStream_GetAmplification(g_interProcess.m_Handle, m_StreamHandle);
+  }
+
+  void CStream::SetAmplification(float Amplify)
+  {
+    return g_interProcess.m_Callbacks->AudioEngineStream.AEStream_SetAmplification(g_interProcess.m_Handle, m_StreamHandle, Amplify);
+  }
+
+  const unsigned int CStream::GetFrameSize() const
+  {
+    return g_interProcess.m_Callbacks->AudioEngineStream.AEStream_GetFrameSize(g_interProcess.m_Handle, m_StreamHandle);
+  }
+
+  const unsigned int CStream::GetChannelCount() const
+  {
+    return g_interProcess.m_Callbacks->AudioEngineStream.AEStream_GetChannelCount(g_interProcess.m_Handle, m_StreamHandle);
+  }
+
+  const unsigned int CStream::GetSampleRate() const
+  {
+    return g_interProcess.m_Callbacks->AudioEngineStream.AEStream_GetSampleRate(g_interProcess.m_Handle, m_StreamHandle);
+  }
+
+  const AEDataFormat CStream::GetDataFormat() const
+  {
+    return (AEDataFormat)g_interProcess.m_Callbacks->AudioEngineStream.AEStream_GetDataFormat(g_interProcess.m_Handle, m_StreamHandle);
+  }
+
+  double CStream::GetResampleRatio()
+  {
+    return g_interProcess.m_Callbacks->AudioEngineStream.AEStream_GetResampleRatio(g_interProcess.m_Handle, m_StreamHandle);
+  }
+
+  void CStream::SetResampleRatio(double Ratio)
+  {
+    g_interProcess.m_Callbacks->AudioEngineStream.AEStream_SetResampleRatio(g_interProcess.m_Handle, m_StreamHandle, Ratio);
+  }
+
+} /* namespace AudioEngine */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/dlfcn-win32.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/dlfcn-win32.cpp
new file mode 100644
index 0000000000..127c3e2e5d
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/dlfcn-win32.cpp
@@ -0,0 +1,262 @@
+/*
+ * dlfcn-win32
+ * Copyright (c) 2007 Ramiro Polla
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <windows.h>
+#include <stdio.h>
+
+#include "dlfcn-win32.h"
+
+/* Note:
+ * MSDN says these functions are not thread-safe. We make no efforts to have
+ * any kind of thread safety.
+ */
+
+/* I have no special reason to have set MAX_GLOBAL_OBJECTS to this value. Any
+ * comments are welcome.
+ */
+#define MAX_OBJECTS 255
+
+static HMODULE global_objects[MAX_OBJECTS];
+
+/* This function adds an object to the list of global objects.
+ * The implementation is very simple and slow.
+ * TODO: should failing this function be enough to fail the call to dlopen( )?
+ */
+static void global_object_add( HMODULE hModule )
+{
+    int i;
+
+    for( i = 0 ; i < MAX_OBJECTS ; i++ )
+    {
+        if( !global_objects[i] )
+        {
+            global_objects[i] = hModule;
+            break;
+        }
+    }
+}
+
+static void global_object_rem( HMODULE hModule )
+{
+    int i;
+
+    for( i = 0 ; i < MAX_OBJECTS ; i++ )
+    {
+        if( global_objects[i] == hModule )
+        {
+            global_objects[i] = 0;
+            break;
+        }
+    }
+}
+
+/* Argument to last function. Used in dlerror( ) */
+static char last_name[MAX_PATH];
+
+static int copy_string( char *dest, int dest_size, const char *src )
+{
+    int i = 0;
+
+    if( src && dest )
+    {
+        for( i = 0 ; i < dest_size-1 ; i++ )
+        {
+            if( !src[i] )
+                break;
+            else
+                dest[i] = src[i];
+        }
+    }
+    dest[i] = '\0';
+
+    return i;
+}
+
+void *dlopen( const char *file, int mode )
+{
+    HMODULE hModule;
+    UINT uMode;
+
+    /* Do not let Windows display the critical-error-handler message box */
+    uMode = SetErrorMode( SEM_FAILCRITICALERRORS );
+
+    if( file == 0 )
+    {
+        /* Save NULL pointer for error message */
+        _snprintf_s( last_name, MAX_PATH, MAX_PATH, "0x%p", file );
+
+        /* POSIX says that if the value of file is 0, a handle on a global
+         * symbol object must be provided. That object must be able to access
+         * all symbols from the original program file, and any objects loaded
+         * with the RTLD_GLOBAL flag.
+         * The return value from GetModuleHandle( ) allows us to retrieve
+         * symbols only from the original program file. For objects loaded with
+         * the RTLD_GLOBAL flag, we create our own list later on.
+         */
+        hModule = GetModuleHandle( NULL );
+    }
+    else
+    {
+        char lpFileName[MAX_PATH];
+        int i;
+
+        /* MSDN says backslashes *must* be used instead of forward slashes. */
+        for( i = 0 ; i < sizeof(lpFileName)-1 ; i++ )
+        {
+            if( !file[i] )
+                break;
+            else if( file[i] == '/' )
+                lpFileName[i] = '\\';
+            else
+                lpFileName[i] = file[i];
+        }
+        lpFileName[i] = '\0';
+
+        /* Save file name for error message */
+        copy_string( last_name, sizeof(last_name), lpFileName );
+
+        /* POSIX says the search path is implementation-defined.
+         * LOAD_WITH_ALTERED_SEARCH_PATH is used to make it behave more closely
+         * to UNIX's search paths (start with system folders instead of current
+         * folder).
+         */
+        hModule = LoadLibraryEx( (LPSTR) lpFileName, NULL,
+                                 LOAD_WITH_ALTERED_SEARCH_PATH );
+        /* If the object was loaded with RTLD_GLOBAL, add it to list of global
+         * objects, so that its symbols may be retrieved even if the handle for
+         * the original program file is passed. POSIX says that if the same
+         * file is specified in multiple invocations, and any of them are
+         * RTLD_GLOBAL, even if any further invocations use RTLD_LOCAL, the
+         * symbols will remain global.
+         */
+
+        if( hModule && (mode & RTLD_GLOBAL) )
+            global_object_add( hModule );
+    }
+
+    /* Return to previous state of the error-mode bit flags. */
+    SetErrorMode( uMode );
+
+    return (void *) hModule;
+}
+
+int dlclose( void *handle )
+{
+    HMODULE hModule = (HMODULE) handle;
+    BOOL ret;
+
+    /* Save handle for error message */
+    _snprintf_s( last_name, MAX_PATH, MAX_PATH, "0x%p", handle );
+
+    ret = FreeLibrary( hModule );
+
+    /* If the object was loaded with RTLD_GLOBAL, remove it from list of global
+     * objects.
+     */
+    if( ret )
+        global_object_rem( hModule );
+
+    /* dlclose's return value in inverted in relation to FreeLibrary's. */
+    ret = !ret;
+
+    return (int) ret;
+}
+
+void *dlsym( void *handle, const char *name )
+{
+    FARPROC symbol;
+    HMODULE myhandle = (HMODULE) handle;
+
+    /* Save symbol name for error message */
+    copy_string( last_name, sizeof(last_name), name );
+
+    symbol = GetProcAddress( myhandle, name );
+#if 0
+    if( symbol == NULL )
+    {
+        HMODULE hModule;
+
+        /* If the handle for the original program file is passed, also search
+         * in all globally loaded objects.
+         */
+
+        hModule = GetModuleHandle( NULL );
+
+        if( hModule == handle )
+        {
+            int i;
+
+            for( i = 0 ; i < MAX_OBJECTS ; i++ )
+            {
+                if( global_objects[i] != 0 )
+                {
+                    symbol = GetProcAddress( global_objects[i], name );
+                    if( symbol != NULL )
+                        break;
+                }
+            }
+        }
+
+
+        CloseHandle( hModule );
+    }
+#endif
+    return (void*) symbol;
+}
+
+char *dlerror( void )
+{
+    DWORD dwMessageId;
+    /* POSIX says this function doesn't have to be thread-safe, so we use one
+     * static buffer.
+     * MSDN says the buffer cannot be larger than 64K bytes, so we set it to
+     * the limit.
+     */
+    static char lpBuffer[65535];
+    DWORD ret;
+
+    dwMessageId = GetLastError( );
+
+    if( dwMessageId == 0 )
+        return NULL;
+
+    /* Format error message to:
+     * "<argument to function that failed>": <Windows localized error message>
+     */
+    ret  = copy_string( lpBuffer, sizeof(lpBuffer), "\"" );
+    ret += copy_string( lpBuffer+ret, sizeof(lpBuffer)-ret, last_name );
+    ret += copy_string( lpBuffer+ret, sizeof(lpBuffer)-ret, "\": " );
+    ret += FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwMessageId,
+                          MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ),
+                          lpBuffer+ret, sizeof(lpBuffer)-ret, NULL );
+
+    if( ret > 1 )
+    {
+        /* POSIX says the string must not have trailing <newline> */
+        if( lpBuffer[ret-2] == '\r' && lpBuffer[ret-1] == '\n' )
+            lpBuffer[ret-2] = '\0';
+    }
+
+    /* POSIX says that invoking dlerror( ) a second time, immediately following
+     * a prior invocation, shall result in NULL being returned.
+     */
+    SetLastError(0);
+
+    return lpBuffer;
+}
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/dlfcn-win32.h b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/dlfcn-win32.h
new file mode 100644
index 0000000000..b93a029f29
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/dlfcn-win32.h
@@ -0,0 +1,46 @@
+#pragma once
+/*
+ * dlfcn-win32
+ * Copyright (c) 2007 Ramiro Polla
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef DLFCN_H
+#define DLFCN_H
+
+/* POSIX says these are implementation-defined.
+ * To simplify use with Windows API, we treat them the same way.
+ */
+
+#define RTLD_LAZY   0
+#define RTLD_NOW    0
+
+#define RTLD_GLOBAL (1 << 1)
+#define RTLD_LOCAL  (1 << 2)
+
+/* These two were added in The Open Group Base Specifications Issue 6.
+ * Note: All other RTLD_* flags in any dlfcn.h are not standard compliant.
+ */
+
+#define RTLD_DEFAULT    0
+#define RTLD_NEXT       0
+
+void *dlopen ( const char *file, int mode );
+int   dlclose( void *handle );
+void *dlsym  ( void *handle, const char *name );
+char *dlerror( void );
+
+#endif /* DLFCN-WIN32_H */
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlButton.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlButton.cpp
new file mode 100644
index 0000000000..4e4dd56072
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlButton.cpp
@@ -0,0 +1,90 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, gui/ControlButton.hpp)
+#include KITINCLUDE(ADDON_API_LEVEL, gui/Window.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace GUI
+{
+
+  CControlButton::CControlButton(CWindow* window, int controlId)
+   : m_Window(window),
+     m_ControlId(controlId)
+  {
+    m_ControlHandle = g_interProcess.m_Callbacks->GUI.Window.GetControl_Button(g_interProcess.m_Handle, m_Window->m_WindowHandle, controlId);
+    if (!m_ControlHandle)
+      fprintf(stderr, "libKODI_guilib-ERROR: CControlButton can't create control class from Kodi !!!\n");
+  }
+
+  CControlButton::~CControlButton()
+  {
+  }
+
+  void CControlButton::SetVisible(bool visible)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Button.SetVisible(g_interProcess.m_Handle, m_ControlHandle, visible);
+  }
+
+  void CControlButton::SetEnabled(bool enabled)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Button.SetEnabled(g_interProcess.m_Handle, m_ControlHandle, enabled);
+  }
+
+  void CControlButton::SetLabel(const std::string& label)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Button.SetLabel(g_interProcess.m_Handle, m_ControlHandle, label.c_str());
+  }
+
+  std::string CControlButton::GetLabel() const
+  {
+    std::string text;
+    text.resize(1024);
+    unsigned int size = (unsigned int)text.capacity();
+    g_interProcess.m_Callbacks->GUI.Control.Button.GetLabel(g_interProcess.m_Handle, m_ControlHandle, text[0], size);
+    text.resize(size);
+    text.shrink_to_fit();
+    return text;
+  }
+
+  void CControlButton::SetLabel2(const std::string& label)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Button.SetLabel2(g_interProcess.m_Handle, m_ControlHandle, label.c_str());
+  }
+
+  std::string CControlButton::GetLabel2() const
+  {
+    std::string text;
+    text.resize(1024);
+    unsigned int size = (unsigned int)text.capacity();
+    g_interProcess.m_Callbacks->GUI.Control.Button.GetLabel2(g_interProcess.m_Handle, m_ControlHandle, text[0], size);
+    text.resize(size);
+    text.shrink_to_fit();
+    return text;
+  }
+
+} /* namespace GUI */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlEdit.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlEdit.cpp
new file mode 100644
index 0000000000..148a8aa87d
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlEdit.cpp
@@ -0,0 +1,105 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, gui/ControlEdit.hpp)
+#include KITINCLUDE(ADDON_API_LEVEL, gui/Window.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace GUI
+{
+
+  CControlEdit::CControlEdit(CWindow* window, int controlId)
+   : m_Window(window),
+     m_ControlId(controlId)
+  {
+    m_ControlHandle = g_interProcess.m_Callbacks->GUI.Window.GetControl_Edit(g_interProcess.m_Handle, m_Window->m_WindowHandle, controlId);
+    if (!m_ControlHandle)
+      fprintf(stderr, "libKODI_guilib-ERROR: CControlEdit can't create control class from Kodi !!!\n");
+  }
+
+  CControlEdit::~CControlEdit()
+  {
+  }
+
+  void CControlEdit::SetVisible(bool visible)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Edit.SetVisible(g_interProcess.m_Handle, m_ControlHandle, visible);
+  }
+
+  void CControlEdit::SetEnabled(bool enabled)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Edit.SetEnabled(g_interProcess.m_Handle, m_ControlHandle, enabled);
+  }
+
+  void CControlEdit::SetLabel(const std::string& label)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Edit.SetLabel(g_interProcess.m_Handle, m_ControlHandle, label.c_str());
+  }
+
+  std::string CControlEdit::GetLabel() const
+  {
+    std::string text;
+    text.resize(1024);
+    unsigned int size = (unsigned int)text.capacity();
+    g_interProcess.m_Callbacks->GUI.Control.Edit.GetLabel(g_interProcess.m_Handle, m_ControlHandle, text[0], size);
+    text.resize(size);
+    text.shrink_to_fit();
+    return text;
+  }
+
+  void CControlEdit::SetText(const std::string& text)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Edit.SetText(g_interProcess.m_Handle, m_ControlHandle, text.c_str());
+  }
+
+  std::string CControlEdit::GetText() const
+  {
+    std::string text;
+    text.resize(1024);
+    unsigned int size = (unsigned int)text.capacity();
+    g_interProcess.m_Callbacks->GUI.Control.Edit.GetText(g_interProcess.m_Handle, m_ControlHandle, text[0], size);
+    text.resize(size);
+    text.shrink_to_fit();
+    return text;
+  }
+
+  void CControlEdit::SetCursorPosition(unsigned int iPosition)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Edit.SetCursorPosition(g_interProcess.m_Handle, m_ControlHandle, iPosition);
+  }
+
+  unsigned int CControlEdit::GetCursorPosition()
+  {
+    return g_interProcess.m_Callbacks->GUI.Control.Edit.GetCursorPosition(g_interProcess.m_Handle, m_ControlHandle);
+  }
+
+  void CControlEdit::SetInputType(AddonGUIInputType type, const std::string& heading)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Edit.SetInputType(g_interProcess.m_Handle, m_ControlHandle, type, heading.c_str());
+  }
+
+} /* namespace GUI */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlFadeLabel.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlFadeLabel.cpp
new file mode 100644
index 0000000000..4fd1be9013
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlFadeLabel.cpp
@@ -0,0 +1,79 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, gui/ControlFadeLabel.hpp)
+#include KITINCLUDE(ADDON_API_LEVEL, gui/Window.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace GUI
+{
+
+  CControlFadeLabel::CControlFadeLabel(CWindow* window, int controlId)
+   : m_Window(window),
+     m_ControlId(controlId)
+  {
+    m_ControlHandle = g_interProcess.m_Callbacks->GUI.Window.GetControl_FadeLabel(g_interProcess.m_Handle, m_Window->m_WindowHandle, controlId);
+    if (!m_ControlHandle)
+      fprintf(stderr, "libKODI_guilib-ERROR: CControlFadeLabel can't create control class from Kodi !!!\n");
+  }
+
+  CControlFadeLabel::~CControlFadeLabel()
+  {
+  }
+
+  void CControlFadeLabel::SetVisible(bool visible)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.FadeLabel.SetVisible(g_interProcess.m_Handle, m_ControlHandle, visible);
+  }
+
+  void CControlFadeLabel::AddLabel(const std::string& text)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.FadeLabel.AddLabel(g_interProcess.m_Handle, m_ControlHandle, text.c_str());
+  }
+
+  std::string CControlFadeLabel::GetLabel() const
+  {
+    std::string text;
+    text.resize(1024);
+    unsigned int size = (unsigned int)text.capacity();
+    g_interProcess.m_Callbacks->GUI.Control.FadeLabel.GetLabel(g_interProcess.m_Handle, m_ControlHandle, text[0], size);
+    text.resize(size);
+    text.shrink_to_fit();
+    return text;
+  }
+
+  void CControlFadeLabel::SetScrolling(bool scroll)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.FadeLabel.SetScrolling(g_interProcess.m_Handle, m_ControlHandle, scroll);
+  }
+
+  void CControlFadeLabel::Reset()
+  {
+    g_interProcess.m_Callbacks->GUI.Control.FadeLabel.Reset(g_interProcess.m_Handle, m_ControlHandle);
+  }
+
+} /* namespace GUI */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlImage.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlImage.cpp
new file mode 100644
index 0000000000..d3ef29d56b
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlImage.cpp
@@ -0,0 +1,63 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, gui/ControlImage.hpp)
+#include KITINCLUDE(ADDON_API_LEVEL, gui/Window.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace GUI
+{
+
+  CControlImage::CControlImage(CWindow* window, int controlId)
+   : m_Window(window),
+     m_ControlId(controlId)
+  {
+    m_ControlHandle = g_interProcess.m_Callbacks->GUI.Window.GetControl_Image(g_interProcess.m_Handle, m_Window->m_WindowHandle, controlId);
+    if (!m_ControlHandle)
+      fprintf(stderr, "libKODI_guilib-ERROR: CControlImage can't create control class from Kodi !!!\n");
+  }
+
+  CControlImage::~CControlImage()
+  {
+  }
+
+  void CControlImage::SetVisible(bool visible)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Image.SetVisible(g_interProcess.m_Handle, m_ControlHandle, visible);
+  }
+
+  void CControlImage::SetFileName(const std::string& strFileName, const bool useCache)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Image.SetFileName(g_interProcess.m_Handle, m_ControlHandle, strFileName.c_str(), useCache);
+  }
+
+  void CControlImage::SetColorDiffuse(uint32_t colorDiffuse)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Image.SetColorDiffuse(g_interProcess.m_Handle, m_ControlHandle, colorDiffuse);
+  }
+
+} /* namespace GUI */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlLabel.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlLabel.cpp
new file mode 100644
index 0000000000..1797338537
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlLabel.cpp
@@ -0,0 +1,69 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, gui/ControlLabel.hpp)
+#include KITINCLUDE(ADDON_API_LEVEL, gui/Window.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace GUI
+{
+
+  CControlLabel::CControlLabel(CWindow* window, int controlId)
+   : m_Window(window),
+     m_ControlId(controlId)
+  {
+    m_ControlHandle = g_interProcess.m_Callbacks->GUI.Window.GetControl_Label(g_interProcess.m_Handle, m_Window->m_WindowHandle, controlId);
+    if (!m_ControlHandle)
+      fprintf(stderr, "libKODI_guilib-ERROR: CControlLabel can't create control class from Kodi !!!\n");
+  }
+
+  CControlLabel::~CControlLabel()
+  {
+  }
+
+  void CControlLabel::SetVisible(bool visible)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Label.SetVisible(g_interProcess.m_Handle, m_ControlHandle, visible);
+  }
+
+  void CControlLabel::SetLabel(const std::string& text)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Label.SetLabel(g_interProcess.m_Handle, m_ControlHandle, text.c_str());
+  }
+
+  std::string CControlLabel::GetLabel() const
+  {
+    std::string text;
+    text.resize(1024);
+    unsigned int size = (unsigned int)text.capacity();
+    g_interProcess.m_Callbacks->GUI.Control.Label.GetLabel(g_interProcess.m_Handle, m_ControlHandle, text[0], size);
+    text.resize(size);
+    text.shrink_to_fit();
+    return text;
+  }
+
+} /* namespace GUI */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlProgress.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlProgress.cpp
new file mode 100644
index 0000000000..9e4c25f2d2
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlProgress.cpp
@@ -0,0 +1,63 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, gui/ControlProgress.hpp)
+#include KITINCLUDE(ADDON_API_LEVEL, gui/Window.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace GUI
+{
+
+  CControlProgress::CControlProgress(CWindow* window, int controlId)
+   : m_Window(window),
+     m_ControlId(controlId)
+  {
+    m_ControlHandle = g_interProcess.m_Callbacks->GUI.Window.GetControl_Progress(g_interProcess.m_Handle, m_Window->m_WindowHandle, controlId);
+    if (!m_ControlHandle)
+      fprintf(stderr, "libKODI_guilib-ERROR: CControlProgress can't create control class from Kodi !!!\n");
+  }
+
+  CControlProgress::~CControlProgress()
+  {
+  }
+
+  void CControlProgress::SetVisible(bool visible)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Progress.SetVisible(g_interProcess.m_Handle, m_ControlHandle, visible);
+  }
+
+  void CControlProgress::SetPercentage(float percent)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Progress.SetPercentage(g_interProcess.m_Handle, m_ControlHandle, percent);
+  }
+
+  float CControlProgress::GetPercentage() const
+  {
+    return g_interProcess.m_Callbacks->GUI.Control.Progress.GetPercentage(g_interProcess.m_Handle, m_ControlHandle);
+  }
+
+} /* namespace GUI */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlRadioButton.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlRadioButton.cpp
new file mode 100644
index 0000000000..a5e897fc7c
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlRadioButton.cpp
@@ -0,0 +1,84 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, gui/ControlRadioButton.hpp)
+#include KITINCLUDE(ADDON_API_LEVEL, gui/Window.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace GUI
+{
+
+  CControlRadioButton::CControlRadioButton(CWindow* window, int controlId)
+   : m_Window(window),
+     m_ControlId(controlId)
+  {
+    m_ControlHandle = g_interProcess.m_Callbacks->GUI.Window.GetControl_RadioButton(g_interProcess.m_Handle, m_Window->m_WindowHandle, controlId);
+    if (!m_ControlHandle)
+      fprintf(stderr, "libKODI_guilib-ERROR: CControlRadioButton can't create control class from Kodi !!!\n");
+  }
+
+  CControlRadioButton::~CControlRadioButton()
+  {
+  }
+
+  void CControlRadioButton::SetVisible(bool visible)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.RadioButton.SetVisible(g_interProcess.m_Handle, m_ControlHandle, visible);
+  }
+
+  void CControlRadioButton::SetEnabled(bool enabled)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.RadioButton.SetEnabled(g_interProcess.m_Handle, m_ControlHandle, enabled);
+  }
+
+  void CControlRadioButton::SetLabel(const std::string& label)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.RadioButton.SetLabel(g_interProcess.m_Handle, m_ControlHandle, label.c_str());
+  }
+
+  std::string CControlRadioButton::GetLabel() const
+  {
+    std::string text;
+    text.resize(1024);
+    unsigned int size = (unsigned int)text.capacity();
+    g_interProcess.m_Callbacks->GUI.Control.RadioButton.GetLabel(g_interProcess.m_Handle, m_ControlHandle, text[0], size);
+    text.resize(size);
+    text.shrink_to_fit();
+    return text;
+  }
+
+  void CControlRadioButton::SetSelected(bool yesNo)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.RadioButton.SetSelected(g_interProcess.m_Handle, m_ControlHandle, yesNo);
+  }
+
+  bool CControlRadioButton::IsSelected() const
+  {
+    return g_interProcess.m_Callbacks->GUI.Control.RadioButton.IsSelected(g_interProcess.m_Handle, m_ControlHandle);
+  }
+
+} /* namespace GUI */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlRendering.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlRendering.cpp
new file mode 100644
index 0000000000..22e4e211ee
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlRendering.cpp
@@ -0,0 +1,107 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, gui/ControlRendering.hpp)
+#include KITINCLUDE(ADDON_API_LEVEL, gui/Window.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace GUI
+{
+
+  CControlRendering::CControlRendering(
+        CWindow*      window,
+        int           controlId)
+   : m_Window(window),
+     m_ControlId(controlId)
+  {
+    m_ControlHandle = g_interProcess.m_Callbacks->GUI.Window.GetControl_RenderAddon(g_interProcess.m_Handle, m_Window->m_WindowHandle, controlId);
+    if (m_ControlHandle)
+      g_interProcess.m_Callbacks->GUI.Control.Rendering.SetCallbacks(g_interProcess.m_Handle, m_ControlHandle, this,
+                                             OnCreateCB, OnRenderCB, OnStopCB, OnDirtyCB);
+    else
+      fprintf(stderr, "ERROR: CControlRendering can't create control class from Kodi !!!\n");
+  }
+
+  CControlRendering::~CControlRendering()
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Rendering.Delete(g_interProcess.m_Handle, m_ControlHandle);
+  }
+
+  /*!
+   * Kodi to add-on override definition function to use if class becomes used
+   * independet.
+   */
+
+  void CControlRendering::SetIndependentCallbacks(
+        GUIHANDLE             cbhdl,
+        bool      (*CBCreate)(GUIHANDLE cbhdl,
+                              int       x,
+                              int       y,
+                              int       w,
+                              int       h,
+                              void*     device),
+        void      (*CBRender)(GUIHANDLE cbhdl),
+        void      (*CBStop)  (GUIHANDLE cbhdl),
+        bool      (*CBDirty) (GUIHANDLE cbhdl))
+  {
+    if (!cbhdl ||
+        !CBCreate || !CBRender || !CBStop || !CBDirty)
+    {
+      fprintf(stderr, "ERROR: CControlRendering - SetIndependentCallbacks called with nullptr !!!\n");
+      return;
+    }
+
+    g_interProcess.m_Callbacks->GUI.Control.Rendering.SetCallbacks(g_interProcess.m_Handle, m_ControlHandle, cbhdl,
+                                         CBCreate, CBRender, CBStop, CBDirty);
+  }
+
+  /*!
+   * Defined callback functions from Kodi to add-on, for use in parent / child system
+   * (is private)!
+   */
+
+  bool CControlRendering::OnCreateCB(GUIHANDLE cbhdl, int x, int y, int w, int h, void* device)
+  {
+    return static_cast<CControlRendering*>(cbhdl)->Create(x, y, w, h, device);
+  }
+
+  void CControlRendering::OnRenderCB(GUIHANDLE cbhdl)
+  {
+    static_cast<CControlRendering*>(cbhdl)->Render();
+  }
+
+  void CControlRendering::OnStopCB(GUIHANDLE cbhdl)
+  {
+    static_cast<CControlRendering*>(cbhdl)->Stop();
+  }
+
+  bool CControlRendering::OnDirtyCB(GUIHANDLE cbhdl)
+  {
+    return static_cast<CControlRendering*>(cbhdl)->Dirty();
+  }
+
+} /* namespace GUI */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlSettingsSlider.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlSettingsSlider.cpp
new file mode 100644
index 0000000000..ccac7e550f
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlSettingsSlider.cpp
@@ -0,0 +1,118 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, gui/ControlSettingsSlider.hpp)
+#include KITINCLUDE(ADDON_API_LEVEL, gui/Window.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace GUI
+{
+
+  CControlSettingsSlider::CControlSettingsSlider(CWindow* window, int controlId)
+   : m_Window(window),
+     m_ControlId(controlId)
+  {
+    m_ControlHandle = g_interProcess.m_Callbacks->GUI.Window.GetControl_SettingsSlider(g_interProcess.m_Handle, m_Window->m_WindowHandle, controlId);
+    if (!m_ControlHandle)
+      fprintf(stderr, "libKODI_guilib-ERROR: CControlSettingsSlider can't create control class from Kodi !!!\n");
+  }
+
+  CControlSettingsSlider::~CControlSettingsSlider()
+  {
+  }
+
+  void CControlSettingsSlider::SetVisible(bool visible)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.SettingsSlider.SetVisible(g_interProcess.m_Handle, m_ControlHandle, visible);
+  }
+
+  void CControlSettingsSlider::SetEnabled(bool enabled)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.SettingsSlider.SetEnabled(g_interProcess.m_Handle, m_ControlHandle, enabled);
+  }
+
+  void CControlSettingsSlider::SetText(const std::string& label)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.SettingsSlider.SetText(g_interProcess.m_Handle, m_ControlHandle, label.c_str());
+  }
+
+  void CControlSettingsSlider::Reset()
+  {
+    g_interProcess.m_Callbacks->GUI.Control.SettingsSlider.Reset(g_interProcess.m_Handle, m_ControlHandle);
+  }
+
+  void CControlSettingsSlider::SetIntRange(int start, int end)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.SettingsSlider.SetIntRange(g_interProcess.m_Handle, m_ControlHandle, start, end);
+  }
+
+  void CControlSettingsSlider::SetIntValue(int value)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.SettingsSlider.SetIntValue(g_interProcess.m_Handle, m_ControlHandle, value);
+  }
+
+  int CControlSettingsSlider::GetIntValue() const
+  {
+    return g_interProcess.m_Callbacks->GUI.Control.SettingsSlider.GetIntValue(g_interProcess.m_Handle, m_ControlHandle);
+  }
+
+  void CControlSettingsSlider::SetIntInterval(int interval)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.SettingsSlider.SetIntInterval(g_interProcess.m_Handle, m_ControlHandle, interval);
+  }
+
+  void CControlSettingsSlider::SetPercentage(float percent)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.SettingsSlider.SetPercentage(g_interProcess.m_Handle, m_ControlHandle, percent);
+  }
+
+  float CControlSettingsSlider::GetPercentage() const
+  {
+    return g_interProcess.m_Callbacks->GUI.Control.SettingsSlider.GetPercentage(g_interProcess.m_Handle, m_ControlHandle);
+  }
+
+  void CControlSettingsSlider::SetFloatRange(float start, float end)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.SettingsSlider.SetFloatRange(g_interProcess.m_Handle, m_ControlHandle, start, end);
+  }
+
+  void CControlSettingsSlider::SetFloatValue(float value)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.SettingsSlider.SetFloatValue(g_interProcess.m_Handle, m_ControlHandle, value);
+  }
+
+  float CControlSettingsSlider::GetFloatValue() const
+  {
+    return g_interProcess.m_Callbacks->GUI.Control.SettingsSlider.GetFloatValue(g_interProcess.m_Handle, m_ControlHandle);
+  }
+
+  void CControlSettingsSlider::SetFloatInterval(float interval)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.SettingsSlider.SetFloatInterval(g_interProcess.m_Handle, m_ControlHandle, interval);
+  }
+
+} /* namespace GUI */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlSlider.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlSlider.cpp
new file mode 100644
index 0000000000..1a2c6de56d
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlSlider.cpp
@@ -0,0 +1,119 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, gui/ControlSlider.hpp)
+#include KITINCLUDE(ADDON_API_LEVEL, gui/Window.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace GUI
+{
+
+  CControlSlider::CControlSlider(CWindow* window, int controlId)
+   : m_Window(window),
+     m_ControlId(controlId)
+  {
+    m_ControlHandle = g_interProcess.m_Callbacks->GUI.Window.GetControl_Slider(g_interProcess.m_Handle, m_Window->m_WindowHandle, controlId);
+    if (!m_ControlHandle)
+      fprintf(stderr, "libKODI_guilib-ERROR: CControlSlider can't create control class from Kodi !!!\n");
+  }
+
+  CControlSlider::~CControlSlider()
+  {
+  }
+
+  void CControlSlider::SetVisible(bool yesNo)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Slider.SetVisible(g_interProcess.m_Handle, m_ControlHandle, yesNo);
+  }
+
+  void CControlSlider::SetEnabled(bool yesNo)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Slider.SetEnabled(g_interProcess.m_Handle, m_ControlHandle, yesNo);
+  }
+
+  std::string CControlSlider::GetDescription() const
+  {
+    std::string text;
+    text.resize(1024);
+    unsigned int size = (unsigned int)text.capacity();
+    g_interProcess.m_Callbacks->GUI.Control.Slider.GetDescription(g_interProcess.m_Handle, m_ControlHandle, text[0], size);
+    text.resize(size);
+    text.shrink_to_fit();
+    return text;
+  }
+
+  void CControlSlider::SetIntRange(int start, int end)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Slider.SetIntRange(g_interProcess.m_Handle, m_ControlHandle, start, end);
+  }
+
+  void CControlSlider::SetIntValue(int value)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Slider.SetIntValue(g_interProcess.m_Handle, m_ControlHandle, value);
+  }
+
+  int CControlSlider::GetIntValue() const
+  {
+    return g_interProcess.m_Callbacks->GUI.Control.Slider.GetIntValue(g_interProcess.m_Handle, m_ControlHandle);
+  }
+
+  void CControlSlider::SetIntInterval(int interval)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Slider.SetIntInterval(g_interProcess.m_Handle, m_ControlHandle, interval);
+  }
+
+  void CControlSlider::SetPercentage(float percent)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Slider.SetPercentage(g_interProcess.m_Handle, m_ControlHandle, percent);
+  }
+
+  float CControlSlider::GetPercentage() const
+  {
+    return g_interProcess.m_Callbacks->GUI.Control.Slider.GetPercentage(g_interProcess.m_Handle, m_ControlHandle);
+  }
+
+  void CControlSlider::SetFloatRange(float start, float end)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Slider.SetFloatRange(g_interProcess.m_Handle, m_ControlHandle, start, end);
+  }
+
+  void CControlSlider::SetFloatValue(float value)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Slider.SetFloatValue(g_interProcess.m_Handle, m_ControlHandle, value);
+  }
+  
+  float CControlSlider::GetFloatValue() const
+  {
+    return g_interProcess.m_Callbacks->GUI.Control.Slider.GetFloatValue(g_interProcess.m_Handle, m_ControlHandle);
+  }
+  
+  void CControlSlider::SetFloatInterval(float interval)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Slider.SetFloatInterval(g_interProcess.m_Handle, m_ControlHandle, interval);
+  }
+
+} /* namespace GUI */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlSpin.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlSpin.cpp
new file mode 100644
index 0000000000..1fa708d7d2
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlSpin.cpp
@@ -0,0 +1,134 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, gui/ControlSpin.hpp)
+#include KITINCLUDE(ADDON_API_LEVEL, gui/Window.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace GUI
+{
+
+  CControlSpin::CControlSpin(CWindow* window, int controlId)
+   : m_Window(window),
+     m_ControlId(controlId)
+  {
+    m_ControlHandle = g_interProcess.m_Callbacks->GUI.Window.GetControl_Spin(g_interProcess.m_Handle, m_Window->m_WindowHandle, controlId);
+    if (!m_ControlHandle)
+      fprintf(stderr, "libKODI_guilib-ERROR: CControlSpin can't create control class from Kodi !!!\n");
+  }
+
+  CControlSpin::~CControlSpin()
+  {
+  }
+
+  void CControlSpin::SetVisible(bool visible)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Spin.SetVisible(g_interProcess.m_Handle, m_ControlHandle, visible);
+  }
+
+  void CControlSpin::SetEnabled(bool enabled)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Spin.SetEnabled(g_interProcess.m_Handle, m_ControlHandle, enabled);
+  }
+
+  void CControlSpin::SetText(const std::string& label)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Spin.SetText(g_interProcess.m_Handle, m_ControlHandle, label.c_str());
+  }
+
+  void CControlSpin::Reset()
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Spin.Reset(g_interProcess.m_Handle, m_ControlHandle);
+  }
+
+  void CControlSpin::SetType(AddonGUISpinControlType type)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Spin.SetType(g_interProcess.m_Handle, m_ControlHandle, (int)type);
+  }
+
+  void CControlSpin::AddLabel(const std::string& label, const std::string& value)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Spin.AddStringLabel(g_interProcess.m_Handle, m_ControlHandle, label.c_str(), value.c_str());
+  }
+
+  void CControlSpin::AddLabel(const std::string& label, int value)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Spin.AddIntLabel(g_interProcess.m_Handle, m_ControlHandle, label.c_str(), value);
+  }
+
+  void CControlSpin::SetStringValue(const std::string& value)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Spin.SetStringValue(g_interProcess.m_Handle, m_ControlHandle, value.c_str());
+  }
+
+  std::string CControlSpin::GetStringValue() const
+  {
+    std::string text;
+    text.resize(1024);
+    unsigned int size = (unsigned int)text.capacity();
+    g_interProcess.m_Callbacks->GUI.Control.Spin.GetStringValue(g_interProcess.m_Handle, m_ControlHandle, text[0], size);
+    text.resize(size);
+    text.shrink_to_fit();
+    return text;
+  }
+
+  void CControlSpin::SetIntRange(int start, int end)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Spin.SetIntRange(g_interProcess.m_Handle, m_ControlHandle, start, end);
+  }
+
+  void CControlSpin::SetIntValue(int value)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Spin.SetIntValue(g_interProcess.m_Handle, m_ControlHandle, value);
+  }
+
+  int CControlSpin::GetIntValue() const
+  {
+    return g_interProcess.m_Callbacks->GUI.Control.Spin.GetIntValue(g_interProcess.m_Handle, m_ControlHandle);
+  }
+  
+  void CControlSpin::SetFloatRange(float start, float end)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Spin.SetFloatRange(g_interProcess.m_Handle, m_ControlHandle, start, end);
+  }
+  
+  void CControlSpin::SetFloatValue(float value)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Spin.SetFloatValue(g_interProcess.m_Handle, m_ControlHandle, value);
+  }
+  
+  float CControlSpin::GetFloatValue() const
+  {
+    return g_interProcess.m_Callbacks->GUI.Control.Spin.GetFloatValue(g_interProcess.m_Handle, m_ControlHandle);
+  }
+  
+  void CControlSpin::SetFloatInterval(float interval)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.Spin.SetFloatInterval(g_interProcess.m_Handle, m_ControlHandle, interval);
+  }
+
+} /* namespace GUI */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlTextBox.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlTextBox.cpp
new file mode 100644
index 0000000000..178445ac62
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ControlTextBox.cpp
@@ -0,0 +1,84 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, gui/ControlTextBox.hpp)
+#include KITINCLUDE(ADDON_API_LEVEL, gui/Window.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace GUI
+{
+
+  CControlTextBox::CControlTextBox(CWindow* window, int controlId)
+   : m_Window(window),
+     m_ControlId(controlId)
+  {
+    m_ControlHandle = g_interProcess.m_Callbacks->GUI.Window.GetControl_TextBox(g_interProcess.m_Handle, m_Window->m_WindowHandle, controlId);
+    if (!m_ControlHandle)
+      fprintf(stderr, "libKODI_guilib-ERROR: CControlTextBox can't create control class from Kodi !!!\n");
+  }
+
+  CControlTextBox::~CControlTextBox()
+  {
+  }
+
+  void CControlTextBox::SetVisible(bool visible)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.TextBox.SetVisible(g_interProcess.m_Handle, m_ControlHandle,  visible);
+  }
+
+  void CControlTextBox::Reset()
+  {
+    g_interProcess.m_Callbacks->GUI.Control.TextBox.Reset(m_ControlHandle, m_ControlHandle);
+  }
+
+  void CControlTextBox::SetText(const std::string& text)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.TextBox.SetText(g_interProcess.m_Handle, m_ControlHandle,  text.c_str());
+  }
+
+  std::string CControlTextBox::GetText() const
+  {
+    std::string text;
+    text.resize(16384);
+    unsigned int size = (unsigned int)text.capacity();
+    g_interProcess.m_Callbacks->GUI.Control.TextBox.GetText(g_interProcess.m_Handle, m_ControlHandle, text[0], size);
+    text.resize(size);
+    text.shrink_to_fit();
+    return text;
+  }
+
+  void CControlTextBox::Scroll(unsigned int position)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.TextBox.Scroll(g_interProcess.m_Handle, m_ControlHandle,  position);
+  }
+
+  void CControlTextBox::SetAutoScrolling(int delay, int time, int repeat)
+  {
+    g_interProcess.m_Callbacks->GUI.Control.TextBox.SetAutoScrolling(g_interProcess.m_Handle, m_ControlHandle,  delay, time, repeat);
+  }
+
+} /* namespace GUI */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogContextMenu.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogContextMenu.cpp
new file mode 100644
index 0000000000..39183f8054
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogContextMenu.cpp
@@ -0,0 +1,52 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, gui/DialogContextMenu.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace GUI
+{
+namespace DialogContextMenu
+{
+
+  int Show(
+          const std::string&              heading,
+          const std::vector<std::string>& entries)
+  {
+    unsigned int size = entries.size();
+    const char** cEntries = (const char**)malloc(size*sizeof(const char**));
+    for (unsigned int i = 0; i < size; ++i)
+    {
+      cEntries[i] = entries[i].c_str();
+    }
+    int ret = g_interProcess.m_Callbacks->GUI.Dialogs.ContextMenu.Open(heading.c_str(), cEntries, size);
+    free(cEntries);
+    return ret;
+  }
+
+} /* namespace DialogContextMenu */
+} /* namespace GUI */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogExtendedProgress.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogExtendedProgress.cpp
new file mode 100644
index 0000000000..ebc5c6ac5a
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogExtendedProgress.cpp
@@ -0,0 +1,104 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, gui/DialogExtendedProgress.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace GUI
+{
+
+  CDialogExtendedProgress::CDialogExtendedProgress(const std::string& title)
+  {
+    m_DialogHandle = g_interProcess.m_Callbacks->GUI.Dialogs.ExtendedProgress.New(g_interProcess.m_Handle, title.c_str());
+    if (!m_DialogHandle)
+      fprintf(stderr, "libKODI_guilib-ERROR: CDialogExtendedProgress can't create window class from Kodi !!!\n");
+  }
+
+  CDialogExtendedProgress::~CDialogExtendedProgress()
+  {
+    if (m_DialogHandle)
+      g_interProcess.m_Callbacks->GUI.Dialogs.ExtendedProgress.Delete(g_interProcess.m_Handle, m_DialogHandle);
+  }
+
+  std::string CDialogExtendedProgress::Title() const
+  {
+    std::string text;
+    text.resize(1024);
+    unsigned int size = (unsigned int)text.capacity();
+    g_interProcess.m_Callbacks->GUI.Dialogs.ExtendedProgress.Title(g_interProcess.m_Handle, m_DialogHandle, text[0], size);
+    text.resize(size);
+    text.shrink_to_fit();
+    return text;
+  }
+
+  void CDialogExtendedProgress::SetTitle(const std::string& title)
+  {
+    g_interProcess.m_Callbacks->GUI.Dialogs.ExtendedProgress.SetTitle(g_interProcess.m_Handle, m_DialogHandle, title.c_str());
+  }
+
+  std::string CDialogExtendedProgress::Text() const
+  {
+    std::string text;
+    text.resize(1024);
+    unsigned int size = (unsigned int)text.capacity();
+    g_interProcess.m_Callbacks->GUI.Dialogs.ExtendedProgress.Text(g_interProcess.m_Handle, m_DialogHandle, text[0], size);
+    text.resize(size);
+    text.shrink_to_fit();
+    return text;
+  }
+
+  void CDialogExtendedProgress::SetText(const std::string& text)
+  {
+    g_interProcess.m_Callbacks->GUI.Dialogs.ExtendedProgress.SetText(g_interProcess.m_Handle, m_DialogHandle, text.c_str());
+  }
+
+  bool CDialogExtendedProgress::IsFinished() const
+  {
+    return g_interProcess.m_Callbacks->GUI.Dialogs.ExtendedProgress.IsFinished(g_interProcess.m_Handle, m_DialogHandle);
+  }
+
+  void CDialogExtendedProgress::MarkFinished()
+  {
+    g_interProcess.m_Callbacks->GUI.Dialogs.ExtendedProgress.MarkFinished(g_interProcess.m_Handle, m_DialogHandle);
+  }
+    
+  float CDialogExtendedProgress::Percentage() const
+  {
+    return g_interProcess.m_Callbacks->GUI.Dialogs.ExtendedProgress.Percentage(g_interProcess.m_Handle, m_DialogHandle);
+  }
+    
+  void CDialogExtendedProgress::SetPercentage(float fPercentage)
+  {
+    g_interProcess.m_Callbacks->GUI.Dialogs.ExtendedProgress.SetPercentage(g_interProcess.m_Handle, m_DialogHandle, fPercentage);
+  }
+    
+  void CDialogExtendedProgress::SetProgress(int currentItem, int itemCount)
+  {
+    g_interProcess.m_Callbacks->GUI.Dialogs.ExtendedProgress.SetProgress(g_interProcess.m_Handle, m_DialogHandle, currentItem, itemCount);
+  }
+
+} /* namespace GUI */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogFileBrowser.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogFileBrowser.cpp
new file mode 100644
index 0000000000..96ccd8d69c
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogFileBrowser.cpp
@@ -0,0 +1,148 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, gui/DialogFileBrowser.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace GUI
+{
+namespace DialogFileBrowser
+{
+
+  bool ShowAndGetDirectory(
+          const std::string&      shares,
+          const std::string&      heading,
+          std::string&            path,
+          bool                    bWriteOnly)
+  {
+    path.resize(1024);
+    unsigned int size = (unsigned int)path.capacity();
+    bool ret = g_interProcess.m_Callbacks->GUI.Dialogs.FileBrowser.ShowAndGetDirectory(shares.c_str(), heading.c_str(), path[0], size, bWriteOnly);
+    path.resize(size);
+    path.shrink_to_fit();
+    return ret;
+  }
+
+  bool ShowAndGetFile(
+          const std::string&      shares,
+          const std::string&      mask,
+          const std::string&      heading,
+          std::string&            file,
+          bool                    useThumbs,
+          bool                    useFileDirectories)
+  {
+    file.resize(1024);
+    unsigned int size = (unsigned int)file.capacity();;
+    bool ret = g_interProcess.m_Callbacks->GUI.Dialogs.FileBrowser.ShowAndGetFile(shares.c_str(), mask.c_str(), heading.c_str(), file[0], size, useThumbs, useFileDirectories);
+    file.resize(size);
+    file.shrink_to_fit();
+    return ret;
+  }
+
+  bool ShowAndGetFileFromDir(
+          const std::string&      directory,
+          const std::string&      mask,
+          const std::string&      heading,
+          std::string&            path,
+          bool                    useThumbs,
+          bool                    useFileDirectories,
+          bool                    singleList)
+  {
+    path.resize(1024);
+    unsigned int size = (unsigned int)path.capacity();
+    bool ret = g_interProcess.m_Callbacks->GUI.Dialogs.FileBrowser.ShowAndGetFileFromDir(directory.c_str(), mask.c_str(), heading.c_str(), path[0], size, useThumbs, useFileDirectories, singleList);
+    path.resize(size);
+    path.shrink_to_fit();
+    return ret;
+  }
+
+  bool ShowAndGetFileList(
+          const std::string&      shares,
+          const std::string&      mask,
+          const std::string&      heading,
+          std::vector<std::string> &path,
+          bool                    useThumbs,
+          bool                    useFileDirectories)
+  {
+    char** list;
+    unsigned int listSize = 0;
+    bool ret = g_interProcess.m_Callbacks->GUI.Dialogs.FileBrowser.ShowAndGetFileList(shares.c_str(), mask.c_str(), heading.c_str(), list, listSize, useThumbs, useFileDirectories);
+    if (ret)
+    {
+      for (unsigned int i = 0; i < listSize; ++i)
+        path.push_back(list[i]);
+      g_interProcess.m_Callbacks->GUI.Dialogs.FileBrowser.ClearList(list, listSize);
+    }
+    return ret;
+  }
+
+  bool ShowAndGetSource(
+          std::string&            path,
+          bool                    allowNetworkShares,
+          const std::string&      additionalShare,
+          const std::string&      strType)
+  {
+    path.resize(1024);
+    unsigned int size = (unsigned int)path.capacity();
+    bool ret = g_interProcess.m_Callbacks->GUI.Dialogs.FileBrowser.ShowAndGetSource(path[0], size, allowNetworkShares, additionalShare.c_str(), strType.c_str());
+    path.resize(size);
+    path.shrink_to_fit();
+    return ret;
+  }
+
+  bool ShowAndGetImage(
+          const std::string&      shares,
+          const std::string&      heading,
+          std::string&            path)
+  {
+    path.resize(1024);
+    unsigned int size = (unsigned int)path.capacity();
+    bool ret = g_interProcess.m_Callbacks->GUI.Dialogs.FileBrowser.ShowAndGetImage(shares.c_str(), heading.c_str(), path[0], size);
+    path.resize(size);
+    path.shrink_to_fit();
+    return ret;
+  }
+
+  bool ShowAndGetImageList(
+          const std::string&      shares,
+          const std::string&      heading,
+          std::vector<std::string> &path)
+  {
+    char** list;
+    unsigned int listSize = 0;
+    bool ret = g_interProcess.m_Callbacks->GUI.Dialogs.FileBrowser.ShowAndGetImageList(shares.c_str(), heading.c_str(), list, listSize);
+    if (ret)
+    {
+      for (unsigned int i = 0; i < listSize; ++i)
+        path.push_back(list[i]);
+      g_interProcess.m_Callbacks->GUI.Dialogs.FileBrowser.ClearList(list, listSize);
+    }
+    return ret;
+  }
+
+} /* namespace DialogFileBrowser */
+} /* namespace GUI */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogKeyboard.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogKeyboard.cpp
new file mode 100644
index 0000000000..88fbdc9c1a
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogKeyboard.cpp
@@ -0,0 +1,156 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, gui/DialogKeyboard.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace GUI
+{
+namespace DialogKeyboard
+{
+
+  bool ShowAndGetInput(
+        std::string&            strText,
+        const std::string&      strHeading,
+        bool                    allowEmptyResult,
+        bool                    hiddenInput,
+        unsigned int            autoCloseMs)
+  {
+    strText.resize(1024);
+    unsigned int size = (unsigned int)strText.capacity();
+    bool ret = g_interProcess.m_Callbacks->GUI.Dialogs.Keyboard.ShowAndGetInputWithHead(strText[0], size, strHeading.c_str(), allowEmptyResult, hiddenInput, autoCloseMs);
+    strText.resize(size);
+    strText.shrink_to_fit();
+    return ret;
+  }
+
+  bool ShowAndGetInput(
+        std::string&            strText,
+        bool                    allowEmptyResult,
+        unsigned int            autoCloseMs)
+  {
+    strText.resize(1024);
+    unsigned int size = (unsigned int)strText.capacity();
+    bool ret = g_interProcess.m_Callbacks->GUI.Dialogs.Keyboard.ShowAndGetInput(strText[0], size, allowEmptyResult, autoCloseMs);
+    strText.resize(size);
+    strText.shrink_to_fit();
+    return ret;
+  }
+
+  bool ShowAndGetNewPassword(
+        std::string&            strNewPassword,
+        const std::string&      strHeading,
+        bool                    allowEmptyResult,
+        unsigned int            autoCloseMs)
+  {
+    strNewPassword.resize(1024);
+    unsigned int size = (unsigned int)strNewPassword.capacity();
+    bool ret = g_interProcess.m_Callbacks->GUI.Dialogs.Keyboard.ShowAndGetNewPasswordWithHead(strNewPassword[0], size, strHeading.c_str(), allowEmptyResult, autoCloseMs);
+    strNewPassword.resize(size);
+    strNewPassword.shrink_to_fit();
+    return ret;
+  }
+
+  bool ShowAndGetNewPassword(
+        std::string&            strNewPassword,
+        unsigned int            autoCloseMs)
+  {
+    strNewPassword.resize(1024);
+    unsigned int size = (unsigned int)strNewPassword.capacity();
+    bool ret = g_interProcess.m_Callbacks->GUI.Dialogs.Keyboard.ShowAndGetNewPassword(strNewPassword[0], size, autoCloseMs);
+    strNewPassword.resize(size);
+    strNewPassword.shrink_to_fit();
+    return ret;
+  }
+
+  bool ShowAndVerifyNewPassword(
+        std::string&            strNewPassword,
+        const std::string&      strHeading,
+        bool                    allowEmptyResult,
+        unsigned int            autoCloseMs)
+  {
+    strNewPassword.resize(1024);
+    unsigned int size = (unsigned int)strNewPassword.capacity();
+    bool ret = g_interProcess.m_Callbacks->GUI.Dialogs.Keyboard.ShowAndGetNewPasswordWithHead(strNewPassword[0], size, strHeading.c_str(), allowEmptyResult, autoCloseMs);
+    strNewPassword.resize(size);
+    strNewPassword.shrink_to_fit();
+    return ret;
+  }
+
+  bool ShowAndVerifyNewPassword(
+        std::string&            strNewPassword,
+        unsigned int            autoCloseMs)
+  {
+    strNewPassword.resize(1024);
+    unsigned int size = (unsigned int)strNewPassword.capacity();
+    bool ret = g_interProcess.m_Callbacks->GUI.Dialogs.Keyboard.ShowAndVerifyNewPassword(strNewPassword[0], size, autoCloseMs);
+    strNewPassword.resize(size);
+    strNewPassword.shrink_to_fit();
+    return ret;
+  }
+
+  int ShowAndVerifyPassword(
+        std::string&            strPassword,
+        const std::string&      strHeading,
+        int                     iRetries,
+        unsigned int            autoCloseMs)
+  {
+    strPassword.resize(1024);
+    unsigned int size = (unsigned int)strPassword.capacity();
+    int ret = g_interProcess.m_Callbacks->GUI.Dialogs.Keyboard.ShowAndVerifyPassword(strPassword[0], size, strHeading.c_str(), iRetries, autoCloseMs);
+    strPassword.resize(size);
+    strPassword.shrink_to_fit();
+    return ret;
+  }
+
+  bool ShowAndGetFilter(
+        std::string&            strText,
+        bool                    searching,
+        unsigned int            autoCloseMs)
+  {
+    strText.resize(1024);
+    unsigned int size = (unsigned int)strText.capacity();
+    bool ret = g_interProcess.m_Callbacks->GUI.Dialogs.Keyboard.ShowAndGetFilter(strText[0], size, searching, autoCloseMs);
+    strText.resize(size);
+    strText.shrink_to_fit();
+    return ret;
+  }
+
+  bool SendTextToActiveKeyboard(
+        const std::string&      aTextString,
+        bool                    closeKeyboard)
+  {
+    return g_interProcess.m_Callbacks->GUI.Dialogs.Keyboard.SendTextToActiveKeyboard(aTextString.c_str(), closeKeyboard);
+  }
+
+  bool IsKeyboardActivated()
+  {
+    return g_interProcess.m_Callbacks->GUI.Dialogs.Keyboard.isKeyboardActivated();
+  }
+
+} /* namespace DialogKeyboard */
+} /* namespace GUI */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogNumeric.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogNumeric.cpp
new file mode 100644
index 0000000000..1b2e3e4b81
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogNumeric.cpp
@@ -0,0 +1,125 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, gui/DialogNumeric.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace GUI
+{
+namespace DialogNumeric
+{
+
+  bool ShowAndVerifyNewPassword(
+          std::string&            strNewPassword)
+  {
+    strNewPassword.reserve(1024);
+    unsigned int size = (unsigned int)strNewPassword.capacity();
+    bool ret = g_interProcess.m_Callbacks->GUI.Dialogs.Numeric.ShowAndVerifyNewPassword(strNewPassword[0], size);
+    strNewPassword.resize(size);
+    strNewPassword.shrink_to_fit();
+    return ret;
+  }
+
+  int ShowAndVerifyPassword(
+          std::string&            strPassword,
+          const std::string&      strHeading,
+          int                     iRetries)
+  {
+    strPassword.resize(1024);
+    unsigned int size = (unsigned int)strPassword.capacity();
+    bool ret = g_interProcess.m_Callbacks->GUI.Dialogs.Numeric.ShowAndVerifyPassword(strPassword[0], size, strHeading.c_str(), iRetries);
+    strPassword.resize(size);
+    strPassword.shrink_to_fit();
+    return ret;
+  }
+
+  bool ShowAndVerifyInput(
+          std::string&            strToVerify,
+          const std::string&      strHeading,
+          bool                    bVerifyInput)
+  {
+    strToVerify.resize(1024);
+    unsigned int size = (unsigned int)strToVerify.capacity();
+    bool ret = g_interProcess.m_Callbacks->GUI.Dialogs.Numeric.ShowAndVerifyInput(strToVerify[0], size, strHeading.c_str(), bVerifyInput);
+    strToVerify.resize(size);
+    strToVerify.shrink_to_fit();
+    return ret;
+  }
+
+  bool ShowAndGetTime(
+          tm&                     time,
+          const std::string&      strHeading)
+  {
+    return g_interProcess.m_Callbacks->GUI.Dialogs.Numeric.ShowAndGetTime(time, strHeading.c_str());
+  }
+
+  bool ShowAndGetDate(
+          tm&                     date,
+          const std::string&      strHeading)
+  {
+    return g_interProcess.m_Callbacks->GUI.Dialogs.Numeric.ShowAndGetDate(date, strHeading.c_str());
+  }
+
+  bool ShowAndGetIPAddress(
+          std::string&            strIPAddress,
+          const std::string&      strHeading)
+  {
+    strIPAddress.resize(1024);
+    unsigned int size = (unsigned int)strIPAddress.capacity();
+    bool ret = g_interProcess.m_Callbacks->GUI.Dialogs.Numeric.ShowAndGetIPAddress(strIPAddress[0], size, strHeading.c_str());
+    strIPAddress.resize(size);
+    strIPAddress.shrink_to_fit();
+    return ret;
+  }
+
+  bool ShowAndGetNumber(
+          std::string&            strInput,
+          const std::string&      strHeading,
+          unsigned int            iAutoCloseTimeoutMs)
+  {
+    strInput.resize(1024);
+    unsigned int size = (unsigned int)strInput.capacity();
+    bool ret = g_interProcess.m_Callbacks->GUI.Dialogs.Numeric.ShowAndGetNumber(strInput[0], size, strHeading.c_str(), iAutoCloseTimeoutMs);
+    strInput.resize(size);
+    strInput.shrink_to_fit();
+    return ret;
+  }
+
+  bool ShowAndGetSeconds(
+          std::string&            strTime,
+          const std::string&      strHeading)
+  {
+    strTime.resize(1024);
+    unsigned int size = (unsigned int)strTime.capacity();
+    bool ret = g_interProcess.m_Callbacks->GUI.Dialogs.Numeric.ShowAndGetSeconds(strTime[0], size, strHeading.c_str());
+    strTime.resize(size);
+    strTime.shrink_to_fit();
+    return ret;
+  }
+
+} /* namespace DialogNumeric */
+} /* namespace GUI */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogOK.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogOK.cpp
new file mode 100644
index 0000000000..5ffe10bd8f
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogOK.cpp
@@ -0,0 +1,53 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, gui/DialogOK.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace GUI
+{
+namespace DialogOK
+{
+
+  void ShowAndGetInput(
+          const std::string&      heading,
+          const std::string&      text)
+  {
+    g_interProcess.m_Callbacks->GUI.Dialogs.OK.ShowAndGetInputSingleText(heading.c_str(), text.c_str());
+  }
+
+  void ShowAndGetInput(
+          const std::string&      heading,
+          const std::string&      line0,
+          const std::string&      line1,
+          const std::string&      line2)
+  {
+    g_interProcess.m_Callbacks->GUI.Dialogs.OK.ShowAndGetInputLineText(heading.c_str(), line0.c_str(), line1.c_str(), line2.c_str());
+  }
+
+} /* namespace DialogOK */
+} /* namespace GUI */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogProgress.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogProgress.cpp
new file mode 100644
index 0000000000..222021411f
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogProgress.cpp
@@ -0,0 +1,102 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, gui/DialogProgress.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace GUI
+{
+
+  CDialogProgress::CDialogProgress()
+  {
+    m_DialogHandle = g_interProcess.m_Callbacks->GUI.Dialogs.Progress.New(g_interProcess.m_Handle);
+    if (!m_DialogHandle)
+      fprintf(stderr, "libKODI_guilib-ERROR: CDialogProgress can't create window class from Kodi !!!\n");
+  }
+
+  CDialogProgress::~CDialogProgress()
+  {
+    if (m_DialogHandle)
+      g_interProcess.m_Callbacks->GUI.Dialogs.Progress.Delete(g_interProcess.m_Handle, m_DialogHandle);
+  }
+
+  void CDialogProgress::Open()
+  {
+    g_interProcess.m_Callbacks->GUI.Dialogs.Progress.Open(g_interProcess.m_Handle, m_DialogHandle);
+  }
+
+  void CDialogProgress::SetHeading(const std::string& title)
+  {
+    g_interProcess.m_Callbacks->GUI.Dialogs.Progress.SetHeading(g_interProcess.m_Handle, m_DialogHandle, title.c_str());
+  }
+
+  void CDialogProgress::SetLine(unsigned int iLine, const std::string& line)
+  {
+    g_interProcess.m_Callbacks->GUI.Dialogs.Progress.SetLine(g_interProcess.m_Handle, m_DialogHandle, iLine, line.c_str());
+  }
+
+  void CDialogProgress::SetCanCancel(bool bCanCancel)
+  {
+    g_interProcess.m_Callbacks->GUI.Dialogs.Progress.SetCanCancel(g_interProcess.m_Handle, m_DialogHandle, bCanCancel);
+  }
+
+  bool CDialogProgress::IsCanceled() const
+  {
+    return g_interProcess.m_Callbacks->GUI.Dialogs.Progress.IsCanceled(g_interProcess.m_Handle, m_DialogHandle);
+  }
+
+  void CDialogProgress::SetPercentage(int iPercentage)
+  {
+    g_interProcess.m_Callbacks->GUI.Dialogs.Progress.SetPercentage(g_interProcess.m_Handle, m_DialogHandle, iPercentage);
+  }
+
+  int CDialogProgress::GetPercentage() const
+  {
+    return g_interProcess.m_Callbacks->GUI.Dialogs.Progress.GetPercentage(g_interProcess.m_Handle, m_DialogHandle);
+  }
+
+  void CDialogProgress::ShowProgressBar(bool bOnOff)
+  {
+    g_interProcess.m_Callbacks->GUI.Dialogs.Progress.ShowProgressBar(g_interProcess.m_Handle, m_DialogHandle, bOnOff);
+  }
+
+  void CDialogProgress::SetProgressMax(int iMax)
+  {
+    g_interProcess.m_Callbacks->GUI.Dialogs.Progress.SetProgressMax(g_interProcess.m_Handle, m_DialogHandle, iMax);
+  }
+
+  void CDialogProgress::SetProgressAdvance(int nSteps)
+  {
+    g_interProcess.m_Callbacks->GUI.Dialogs.Progress.SetProgressAdvance(g_interProcess.m_Handle, m_DialogHandle, nSteps);
+  }
+
+  bool CDialogProgress::Abort()
+  {
+    return g_interProcess.m_Callbacks->GUI.Dialogs.Progress.Abort(g_interProcess.m_Handle, m_DialogHandle);
+  }
+
+} /* namespace GUI */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogSelect.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogSelect.cpp
new file mode 100644
index 0000000000..dac3f4172b
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogSelect.cpp
@@ -0,0 +1,54 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, gui/DialogSelect.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace GUI
+{
+namespace DialogSelect
+{
+
+  int Show(
+          const std::string&              heading,
+          const std::vector<std::string>& entries,
+          int                             selected,
+          bool                            autoclose)
+  {
+    unsigned int size = entries.size();
+    const char** cEntries = (const char**)malloc(size*sizeof(const char**));
+    for (unsigned int i = 0; i < size; ++i)
+    {
+      cEntries[i] = entries[i].c_str();
+    }
+    int ret = g_interProcess.m_Callbacks->GUI.Dialogs.Select.Open(heading.c_str(), cEntries, size, selected, autoclose);
+    free(cEntries);
+    return ret;
+  }
+
+} /* namespace DialogSelect */
+} /* namespace GUI */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogTextViewer.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogTextViewer.cpp
new file mode 100644
index 0000000000..05a5b237ee
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogTextViewer.cpp
@@ -0,0 +1,44 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, gui/DialogTextViewer.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace GUI
+{
+namespace DialogTextViewer
+{
+
+  void Show(
+          const std::string& heading,
+          const std::string& text)
+  {
+    g_interProcess.m_Callbacks->GUI.Dialogs.TextViewer.Open(heading.c_str(), text.c_str());
+  }
+
+} /* namespace DialogTextViewer */
+} /* namespace GUI */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogYesNo.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogYesNo.cpp
new file mode 100644
index 0000000000..d464d9b7dc
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_DialogYesNo.cpp
@@ -0,0 +1,70 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, gui/DialogYesNo.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace GUI
+{
+namespace DialogYesNo
+{
+
+  bool ShowAndGetInput(
+          const std::string&      heading,
+          const std::string&      text,
+          bool&                   bCanceled,
+          const std::string&      noLabel,
+          const std::string&      yesLabel)
+  {
+    return g_interProcess.m_Callbacks->GUI.Dialogs.YesNo.ShowAndGetInputSingleText(heading.c_str(), text.c_str(), bCanceled, noLabel.c_str(), yesLabel.c_str());
+  }
+
+  bool ShowAndGetInput(
+          const std::string&      heading,
+          const std::string&      line0,
+          const std::string&      line1,
+          const std::string&      line2,
+          const std::string&      noLabel,
+          const std::string&      yesLabel)
+  {
+    return g_interProcess.m_Callbacks->GUI.Dialogs.YesNo.ShowAndGetInputLineText(heading.c_str(), line0.c_str(), line1.c_str(), line2.c_str(), noLabel.c_str(), yesLabel.c_str());
+  }
+
+  bool ShowAndGetInput(
+          const std::string&      heading,
+          const std::string&      line0,
+          const std::string&      line1,
+          const std::string&      line2,
+          bool&                   bCanceled,
+          const std::string&      noLabel,
+          const std::string&      yesLabel)
+  {
+    return g_interProcess.m_Callbacks->GUI.Dialogs.YesNo.ShowAndGetInputLineButtonText(heading.c_str(), line0.c_str(), line1.c_str(), line2.c_str(), bCanceled, noLabel.c_str(), yesLabel.c_str());
+  }
+
+} /* namespace DialogYesNo */
+} /* namespace GUI */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_General.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_General.cpp
new file mode 100644
index 0000000000..fa662ad717
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_General.cpp
@@ -0,0 +1,72 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, gui/General.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace GUI
+{
+namespace General
+{
+
+void Lock()
+{
+  g_interProcess.m_Callbacks->GUI.General.Lock();
+}
+
+void Unlock()
+{
+  g_interProcess.m_Callbacks->GUI.General.Unlock();
+}
+
+int GetScreenHeight()
+{
+  return g_interProcess.m_Callbacks->GUI.General.GetScreenHeight();
+}
+
+int GetScreenWidth()
+{
+  return g_interProcess.m_Callbacks->GUI.General.GetScreenWidth();
+}
+
+int GetVideoResolution()
+{
+  return g_interProcess.m_Callbacks->GUI.General.GetVideoResolution();
+}
+
+int GetCurrentWindowDialogId()
+{
+  return g_interProcess.m_Callbacks->GUI.General.GetCurrentWindowDialogId();
+}
+
+int GetCurrentWindowId()
+{
+  return g_interProcess.m_Callbacks->GUI.General.GetCurrentWindowId();
+}
+
+} /* namespace General */
+} /* namespace GUI */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ListItem.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ListItem.cpp
new file mode 100644
index 0000000000..bb80e44487
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_ListItem.cpp
@@ -0,0 +1,462 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, gui/ListItem.hpp)
+
+#include <cstring>
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace GUI
+{
+
+  CListItem::CListItem(
+    const std::string&      label,
+    const std::string&      label2,
+    const std::string&      iconImage,
+    const std::string&      thumbnailImage,
+    const std::string&      path)
+  {
+    m_ListItemHandle = g_interProcess.m_Callbacks->GUI.ListItem.Create(g_interProcess.m_Handle, label.c_str(),
+                                               label2.c_str(), iconImage.c_str(),
+                                               thumbnailImage.c_str(), path.c_str());
+  }
+
+  CListItem::CListItem(GUIHANDLE listItemHandle)
+  {
+    m_ListItemHandle = listItemHandle;
+  }
+
+  CListItem::~CListItem()
+  {
+    g_interProcess.m_Callbacks->GUI.ListItem.Destroy(g_interProcess.m_Handle, m_ListItemHandle);
+  }
+
+  std::string CListItem::GetLabel()
+  {
+    std::string label;
+    label.resize(1024);
+    unsigned int size = (unsigned int)label.capacity();
+    g_interProcess.m_Callbacks->GUI.ListItem.GetLabel(g_interProcess.m_Handle, m_ListItemHandle, label[0], size);
+    label.resize(size);
+    label.shrink_to_fit();
+    return label.c_str();
+  }
+
+  void CListItem::SetLabel(const std::string &label)
+  {
+    g_interProcess.m_Callbacks->GUI.ListItem.SetLabel(g_interProcess.m_Handle, m_ListItemHandle, label.c_str());
+  }
+
+  std::string CListItem::GetLabel2()
+  {
+    std::string label;
+    label.resize(1024);
+    unsigned int size = (unsigned int)label.capacity();
+    g_interProcess.m_Callbacks->GUI.ListItem.GetLabel2(g_interProcess.m_Handle, m_ListItemHandle, label[0], size);
+    label.resize(size);
+    label.shrink_to_fit();
+    return label.c_str();
+  }
+
+  void CListItem::SetLabel2(const std::string &label)
+  {
+    g_interProcess.m_Callbacks->GUI.ListItem.SetLabel2(g_interProcess.m_Handle, m_ListItemHandle, label.c_str());
+  }
+
+  std::string CListItem::GetIconImage()
+  {
+    std::string image;
+    image.resize(1024);
+    unsigned int size = (unsigned int)image.capacity();
+    g_interProcess.m_Callbacks->GUI.ListItem.GetIconImage(g_interProcess.m_Handle, m_ListItemHandle, image[0], size);
+    image.resize(size);
+    image.shrink_to_fit();
+    return image.c_str();
+  }
+
+  void CListItem::SetIconImage(const std::string &image)
+  {
+    g_interProcess.m_Callbacks->GUI.ListItem.SetIconImage(g_interProcess.m_Handle, m_ListItemHandle, image.c_str());
+  }
+
+  std::string CListItem::GetOverlayImage()
+  {
+    std::string image;
+    image.resize(1024);
+    unsigned int size = (unsigned int)image.capacity();
+    g_interProcess.m_Callbacks->GUI.ListItem.GetOverlayImage(g_interProcess.m_Handle, m_ListItemHandle, image[0], size);
+    image.resize(size);
+    image.shrink_to_fit();
+    return image.c_str();
+  }
+
+  void CListItem::SetOverlayImage(unsigned int image, bool bOnOff /*= false */)
+  {
+    g_interProcess.m_Callbacks->GUI.ListItem.SetOverlayImage(g_interProcess.m_Handle, m_ListItemHandle, image, bOnOff);
+  }
+
+  void CListItem::SetThumbnailImage(const std::string &image)
+  {
+    g_interProcess.m_Callbacks->GUI.ListItem.SetThumbnailImage(g_interProcess.m_Handle, m_ListItemHandle, image.c_str());
+  }
+
+  void CListItem::SetArt(const std::string &type, const std::string &url)
+  {
+    g_interProcess.m_Callbacks->GUI.ListItem.SetArt(g_interProcess.m_Handle, m_ListItemHandle, type.c_str(), url.c_str());
+  }
+
+  std::string CListItem::GetArt(const std::string &type)
+  {
+    std::string strReturn;
+    char* strMsg = g_interProcess.m_Callbacks->GUI.ListItem.GetArt(g_interProcess.m_Handle, m_ListItemHandle, type.c_str());
+    if (strMsg != nullptr)
+    {
+      if (std::strlen(strMsg))
+        strReturn = strMsg;
+      g_interProcess.m_Callbacks->free_string(g_interProcess.m_Handle, strMsg);
+    }
+    return strReturn;
+  }
+
+  void CListItem::SetArtFallback(const std::string &from, const std::string &to)
+  {
+    g_interProcess.m_Callbacks->GUI.ListItem.SetArtFallback(g_interProcess.m_Handle, m_ListItemHandle, from.c_str(), to.c_str());
+  }
+
+  bool CListItem::HasArt(const std::string &type)
+  {
+    return g_interProcess.m_Callbacks->GUI.ListItem.HasArt(g_interProcess.m_Handle, m_ListItemHandle, type.c_str());
+  }
+
+  void CListItem::Select(bool bOnOff)
+  {
+    g_interProcess.m_Callbacks->GUI.ListItem.Select(g_interProcess.m_Handle, m_ListItemHandle, bOnOff);
+  }
+
+  bool CListItem::IsSelected()
+  {
+    return g_interProcess.m_Callbacks->GUI.ListItem.IsSelected(g_interProcess.m_Handle, m_ListItemHandle);
+  }
+
+  bool CListItem::HasIcon()
+  {
+    return g_interProcess.m_Callbacks->GUI.ListItem.HasIcon(g_interProcess.m_Handle, m_ListItemHandle);
+  }
+
+  bool CListItem::HasOverlay()
+  {
+    return g_interProcess.m_Callbacks->GUI.ListItem.HasOverlay(g_interProcess.m_Handle, m_ListItemHandle);
+  }
+
+  bool CListItem::IsFileItem()
+  {
+    return g_interProcess.m_Callbacks->GUI.ListItem.IsFileItem(g_interProcess.m_Handle, m_ListItemHandle);
+  }
+
+  bool CListItem::IsFolder()
+  {
+    return g_interProcess.m_Callbacks->GUI.ListItem.IsFolder(g_interProcess.m_Handle, m_ListItemHandle);
+  }
+
+  void CListItem::SetProperty(const std::string &key, const std::string &value)
+  {
+    g_interProcess.m_Callbacks->GUI.ListItem.SetProperty(g_interProcess.m_Handle, m_ListItemHandle, key.c_str(), value.c_str());
+  }
+
+  std::string CListItem::GetProperty(const std::string &key)
+  {
+    std::string property;
+    property.resize(1024);
+    unsigned int size = (unsigned int)property.capacity();
+    g_interProcess.m_Callbacks->GUI.ListItem.GetProperty(g_interProcess.m_Handle, m_ListItemHandle, key.c_str(), property[0], size);
+    property.resize(size);
+    property.shrink_to_fit();
+    return property;
+  }
+
+  void CListItem::ClearProperty(const std::string &key)
+  {
+    g_interProcess.m_Callbacks->GUI.ListItem.ClearProperty(g_interProcess.m_Handle, m_ListItemHandle, key.c_str());
+  }
+
+  void CListItem::ClearProperties()
+  {
+    g_interProcess.m_Callbacks->GUI.ListItem.ClearProperties(g_interProcess.m_Handle, m_ListItemHandle);
+  }
+
+  bool CListItem::HasProperties()
+  {
+    return g_interProcess.m_Callbacks->GUI.ListItem.HasProperties(g_interProcess.m_Handle, m_ListItemHandle);
+  }
+
+  bool CListItem::HasProperty(const std::string &key)
+  {
+    return g_interProcess.m_Callbacks->GUI.ListItem.HasProperty(g_interProcess.m_Handle, m_ListItemHandle, key.c_str());
+  }
+
+  void CListItem::SetPath(const std::string &path)
+  {
+    g_interProcess.m_Callbacks->GUI.ListItem.SetPath(g_interProcess.m_Handle, m_ListItemHandle, path.c_str());
+  }
+
+  std::string CListItem::GetPath()
+  {
+    std::string strReturn;
+    char* strMsg = g_interProcess.m_Callbacks->GUI.ListItem.GetPath(g_interProcess.m_Handle, m_ListItemHandle);
+    if (strMsg != nullptr)
+    {
+      if (std::strlen(strMsg))
+        strReturn = strMsg;
+      g_interProcess.m_Callbacks->free_string(g_interProcess.m_Handle, strMsg);
+    }
+    return strReturn;
+  }
+
+  int CListItem::GetDuration() const
+  {
+    return g_interProcess.m_Callbacks->GUI.ListItem.GetDuration(g_interProcess.m_Handle, m_ListItemHandle);
+  }
+
+  void CListItem::SetSubtitles(const std::vector<std::string>& subtitleFiles)
+  {
+    unsigned int size = subtitleFiles.size();
+    if (size == 0)
+      return;
+
+    const char** subtitles = (const char**)malloc(size);
+    for (unsigned int i = 0; i < size; ++i)
+      subtitles[i] = subtitleFiles[i].c_str();
+
+    g_interProcess.m_Callbacks->GUI.ListItem.SetSubtitles(g_interProcess.m_Handle, m_ListItemHandle, subtitles, size);
+    free(subtitles);
+  }
+
+  void CListItem::SetMimeType(const std::string& mimetype)
+  {
+    g_interProcess.m_Callbacks->GUI.ListItem.SetMimeType(g_interProcess.m_Handle, m_ListItemHandle, mimetype.c_str());
+  }
+
+  void CListItem::SetContentLookup(bool enable)
+  {
+    g_interProcess.m_Callbacks->GUI.ListItem.SetContentLookup(g_interProcess.m_Handle, m_ListItemHandle, enable);
+  }
+
+  void CListItem::AddContextMenuItems(const std::vector<std::pair<std::string, std::string> >& items, bool replaceItems)
+  {
+    const char*** entries = nullptr;
+    unsigned int size = items.size();
+    if (size != 0)
+    {
+      entries = (const char***)malloc(size*sizeof(const char***));
+      for (unsigned int i = 0; i < size; ++i)
+      {
+        entries[i][0] = items.at(i).first.c_str();
+        entries[i][1] = items.at(i).second.c_str();
+      }
+    }
+
+    g_interProcess.m_Callbacks->GUI.ListItem.AddContextMenuItems(g_interProcess.m_Handle, m_ListItemHandle, entries, size, replaceItems);
+    if (entries)
+      free(entries);
+  }
+
+  void CListItem::AddStreamInfo(const std::string& cType, const std::vector<std::pair<std::string, std::string> >& dictionary)
+  {
+    const char*** entries = nullptr;
+    unsigned int size = dictionary.size();
+    if (size == 0)
+      return;
+
+    entries = (const char***)malloc(size*sizeof(const char***));
+    for (unsigned int i = 0; i < size; ++i)
+    {
+      entries[i][0] = dictionary.at(i).first.c_str();
+      entries[i][1] = dictionary.at(i).second.c_str();
+    }
+
+    g_interProcess.m_Callbacks->GUI.ListItem.AddStreamInfo(g_interProcess.m_Handle, m_ListItemHandle, cType.c_str(), entries, size);
+    free(entries);
+  }
+
+  void CListItem::SetMusicInfo_BOOL(ADDON_MusicInfoTag type, bool value)
+  {   
+    if (type != 0)
+      g_interProcess.m_Callbacks->GUI.ListItem.SetMusicInfo(g_interProcess.m_Handle, m_ListItemHandle, type, &value, sizeof(bool));
+  }
+
+  void CListItem::SetMusicInfo_INT(ADDON_MusicInfoTag type, int value)
+  {
+    if (type != 0)
+      g_interProcess.m_Callbacks->GUI.ListItem.SetMusicInfo(g_interProcess.m_Handle, m_ListItemHandle, type, &value, sizeof(int));
+  }
+
+  void CListItem::SetMusicInfo_UINT(ADDON_MusicInfoTag type, unsigned int value)
+  {
+    if (type != 0)
+      g_interProcess.m_Callbacks->GUI.ListItem.SetMusicInfo(g_interProcess.m_Handle, m_ListItemHandle, type, &value, sizeof(unsigned int));
+  }
+
+  void CListItem::SetMusicInfo_FLOAT(ADDON_MusicInfoTag type, float value)
+  {
+    if (type != 0)
+      g_interProcess.m_Callbacks->GUI.ListItem.SetMusicInfo(g_interProcess.m_Handle, m_ListItemHandle, type, &value, sizeof(float));
+  }
+
+  void CListItem::SetMusicInfo_STRING(ADDON_MusicInfoTag type, std::string value)
+  {
+    if (type != 0)
+      g_interProcess.m_Callbacks->GUI.ListItem.SetMusicInfo(g_interProcess.m_Handle, m_ListItemHandle, type, (void*)value.c_str(), sizeof(const char*));
+  } 
+
+  void CListItem::SetMusicInfo_STRING_LIST(ADDON_MusicInfoTag type, std::vector<std::string> values)
+  {
+    unsigned int size = values.size();
+    if (type == 0 || size == 0)
+      return;
+
+    const char** entries = (const char**)malloc(size*sizeof(const char**));
+    for (unsigned int i = 0; i < size; ++i)
+      entries[i] = values[i].c_str();
+
+    g_interProcess.m_Callbacks->GUI.ListItem.SetMusicInfo(g_interProcess.m_Handle, m_ListItemHandle, type, &entries, size);
+    free(entries);
+  }
+
+  void CListItem::SetVideoInfo_BOOL(ADDON_VideoInfoTag type, bool value)
+  {
+    if (type != 0)
+      g_interProcess.m_Callbacks->GUI.ListItem.SetVideoInfo(g_interProcess.m_Handle, m_ListItemHandle, type, &value, sizeof(bool));
+  }
+
+  void CListItem::SetVideoInfo_INT(ADDON_VideoInfoTag type, int value)
+  {
+    if (type != 0)
+      g_interProcess.m_Callbacks->GUI.ListItem.SetVideoInfo(g_interProcess.m_Handle, m_ListItemHandle, type, &value, sizeof(int));
+  }
+
+  void CListItem::SetVideoInfo_UINT(ADDON_VideoInfoTag type, unsigned int value)
+  {
+    if (type != 0)
+      g_interProcess.m_Callbacks->GUI.ListItem.SetVideoInfo(g_interProcess.m_Handle, m_ListItemHandle, type, &value, sizeof(unsigned int));
+  }
+
+  void CListItem::SetVideoInfo_FLOAT(ADDON_VideoInfoTag type, float value)
+  {
+    if (type != 0)
+      g_interProcess.m_Callbacks->GUI.ListItem.SetVideoInfo(g_interProcess.m_Handle, m_ListItemHandle, type, &value, sizeof(float));
+  }
+
+  void CListItem::SetVideoInfo_STRING(ADDON_VideoInfoTag type, std::string value)
+  {
+    if (type != 0)
+      g_interProcess.m_Callbacks->GUI.ListItem.SetVideoInfo(g_interProcess.m_Handle, m_ListItemHandle, type, (void*)value.c_str(), sizeof(const char*));
+  }
+
+  void CListItem::SetVideoInfo_STRING_LIST(ADDON_VideoInfoTag type, std::vector<std::string> values)
+  {
+    unsigned int size = values.size();
+    if (type == 0 || size == 0)
+      return;
+
+    const char** entries = (const char**)malloc(size*sizeof(const char**));
+    for (unsigned int i = 0; i < size; ++i)
+      entries[i] = values[i].c_str();
+
+    g_interProcess.m_Callbacks->GUI.ListItem.SetVideoInfo(g_interProcess.m_Handle, m_ListItemHandle, type, (void*)entries, size);
+    free(entries);
+  } 
+
+  void CListItem::SetVideoInfo_Resume(ADDON_VideoInfoTag_Resume &resume)
+  { 
+    g_interProcess.m_Callbacks->GUI.ListItem.SetVideoInfo(g_interProcess.m_Handle, m_ListItemHandle, ADDON_VideoInfoTag_resume_DATA, &resume, sizeof(ADDON_VideoInfoTag_resume_DATA));
+  }
+
+  void CListItem::SetVideoInfo_Cast(std::vector<ADDON_VideoInfoTag_Cast> &cast)
+  {
+    unsigned int size = cast.size();
+    if (size == 0)
+      return;
+
+    ADDON_VideoInfoTag_cast_DATA_STRUCT** entries = (ADDON_VideoInfoTag_cast_DATA_STRUCT**)malloc(size*sizeof(ADDON_VideoInfoTag_cast_DATA_STRUCT**));
+    for (unsigned int i = 0; i < size; ++i)
+    {
+      entries[i] = (ADDON_VideoInfoTag_cast_DATA_STRUCT*)malloc(sizeof(ADDON_VideoInfoTag_cast_DATA_STRUCT*));
+      entries[i]->name       = cast[i].name.c_str();
+      entries[i]->role       = cast[i].role.c_str();
+      entries[i]->order      = cast[i].order;
+      entries[i]->thumbnail  = cast[i].thumbnail.c_str();
+    }
+
+    g_interProcess.m_Callbacks->GUI.ListItem.SetVideoInfo(g_interProcess.m_Handle, m_ListItemHandle, ADDON_VideoInfoTag_cast_DATA_LIST, (void*)entries, size);
+    free(entries);
+  }
+
+  void CListItem::SetPictureInfo_BOOL(ADDON_PictureInfoTag type, bool value)
+  {
+    if (type != 0)
+      g_interProcess.m_Callbacks->GUI.ListItem.SetPictureInfo(g_interProcess.m_Handle, m_ListItemHandle, type, &value, sizeof(bool));
+  }
+
+  void CListItem::SetPictureInfo_INT(ADDON_PictureInfoTag type, int value)
+  {
+    if (type != 0)
+      g_interProcess.m_Callbacks->GUI.ListItem.SetPictureInfo(g_interProcess.m_Handle, m_ListItemHandle, type, &value, sizeof(int));
+  }
+
+  void CListItem::SetPictureInfo_UINT(ADDON_PictureInfoTag type, unsigned int value)
+  {
+    if (type != 0)
+      g_interProcess.m_Callbacks->GUI.ListItem.SetPictureInfo(g_interProcess.m_Handle, m_ListItemHandle, type, &value, sizeof(unsigned int));
+  }
+
+  void CListItem::SetPictureInfo_FLOAT(ADDON_PictureInfoTag type, float value)
+  {
+    if (type != 0)
+      g_interProcess.m_Callbacks->GUI.ListItem.SetPictureInfo(g_interProcess.m_Handle, m_ListItemHandle, type, &value, sizeof(float));
+  }
+
+  void CListItem::SetPictureInfo_STRING(ADDON_PictureInfoTag type, std::string value)
+  {
+    if (type != 0)
+      g_interProcess.m_Callbacks->GUI.ListItem.SetPictureInfo(g_interProcess.m_Handle, m_ListItemHandle, type, (void*)value.c_str(), sizeof(const char*));
+  }
+
+  void CListItem::SetPictureInfo_STRING_LIST(ADDON_PictureInfoTag type, std::vector<std::string> values)
+  {
+    unsigned int size = values.size();
+    if (type == 0 || size == 0)
+      return;
+
+    const char** entries = (const char**)malloc(size*sizeof(const char**));
+    for (unsigned int i = 0; i < size; ++i)
+      entries[i] = values[i].c_str();
+
+    g_interProcess.m_Callbacks->GUI.ListItem.SetPictureInfo(g_interProcess.m_Handle, m_ListItemHandle, type, (void*)entries, size);
+    free(entries);
+  }
+
+} /* namespace GUI */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_Window.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_Window.cpp
new file mode 100644
index 0000000000..19ba0198a4
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/gui/AddonLib_GUI_Window.cpp
@@ -0,0 +1,249 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, gui/Window.hpp)
+#include KITINCLUDE(ADDON_API_LEVEL, gui/ListItem.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace GUI
+{
+
+  CWindow::CWindow(
+          const std::string&          xmlFilename,
+          const std::string&          defaultSkin,
+          bool                        forceFallback,
+          bool                        asDialog)
+  {
+    m_WindowHandle = g_interProcess.m_Callbacks->GUI.Window.New(g_interProcess.m_Handle, xmlFilename.c_str(),
+                          defaultSkin.c_str(), forceFallback, asDialog);
+    if (!m_WindowHandle)
+      fprintf(stderr, "libKODI_gui-ERROR: cGUIWindow can't create window class from Kodi !!!\n");
+
+    g_interProcess.m_Callbacks->GUI.Window.SetCallbacks(g_interProcess.m_Handle, m_WindowHandle, this,
+                              OnInitCB, OnClickCB, OnFocusCB, OnActionCB);
+  }
+
+  CWindow::~CWindow()
+  {
+    if (m_WindowHandle)
+      g_interProcess.m_Callbacks->GUI.Window.Delete(g_interProcess.m_Handle, m_WindowHandle);
+  }
+
+  bool CWindow::Show()
+  {
+    return g_interProcess.m_Callbacks->GUI.Window.Show(g_interProcess.m_Handle, m_WindowHandle);
+  }
+
+  void CWindow::Close()
+  {
+    g_interProcess.m_Callbacks->GUI.Window.Close(g_interProcess.m_Handle, m_WindowHandle);
+  }
+
+  void CWindow::DoModal()
+  {
+    g_interProcess.m_Callbacks->GUI.Window.DoModal(g_interProcess.m_Handle, m_WindowHandle);
+  }
+
+  bool CWindow::SetFocusId(int iControlId)
+  {
+    return g_interProcess.m_Callbacks->GUI.Window.SetFocusId(g_interProcess.m_Handle, m_WindowHandle, iControlId);
+  }
+
+  int CWindow::GetFocusId()
+  {
+    return g_interProcess.m_Callbacks->GUI.Window.GetFocusId(g_interProcess.m_Handle, m_WindowHandle);
+  }
+
+  void CWindow::SetProperty(const std::string& key, const std::string& value)
+  {
+    g_interProcess.m_Callbacks->GUI.Window.SetProperty(g_interProcess.m_Handle, m_WindowHandle, key.c_str(), value.c_str());
+  }
+
+  void CWindow::SetPropertyInt(const std::string& key, int value)
+  {
+    g_interProcess.m_Callbacks->GUI.Window.SetPropertyInt(g_interProcess.m_Handle, m_WindowHandle, key.c_str(), value);
+  }
+
+  void CWindow::SetPropertyBool(const std::string& key, bool value)
+  {
+    g_interProcess.m_Callbacks->GUI.Window.SetPropertyBool(g_interProcess.m_Handle, m_WindowHandle, key.c_str(), value);
+  }
+
+  void CWindow::SetPropertyDouble(const std::string& key, double value)
+  {
+    g_interProcess.m_Callbacks->GUI.Window.SetPropertyDouble(g_interProcess.m_Handle, m_WindowHandle, key.c_str(), value);
+  }
+
+  std::string CWindow::GetProperty(const std::string& key) const
+  {
+    std::string label;
+    label.resize(1024);
+    unsigned int size = (unsigned int)label.capacity();
+    g_interProcess.m_Callbacks->GUI.Window.GetProperty(g_interProcess.m_Handle, m_WindowHandle, key.c_str(), label[0], size);
+    label.resize(size);
+    label.shrink_to_fit();
+    return label.c_str();
+  }
+
+  int CWindow::GetPropertyInt(const std::string& key) const
+  {
+    return g_interProcess.m_Callbacks->GUI.Window.GetPropertyInt(g_interProcess.m_Handle, m_WindowHandle, key.c_str());
+  }
+
+  bool CWindow::GetPropertyBool(const std::string& key) const
+  {
+    return g_interProcess.m_Callbacks->GUI.Window.GetPropertyBool(g_interProcess.m_Handle, m_WindowHandle, key.c_str());
+  }
+
+  double CWindow::GetPropertyDouble(const std::string& key) const
+  {
+    return g_interProcess.m_Callbacks->GUI.Window.GetPropertyDouble(g_interProcess.m_Handle, m_WindowHandle, key.c_str());
+  }
+
+  void CWindow::ClearProperties()
+  {
+    g_interProcess.m_Callbacks->GUI.Window.ClearProperties(g_interProcess.m_Handle, m_WindowHandle);
+  }
+
+  void CWindow::ClearProperty(const std::string& key)
+  {
+    g_interProcess.m_Callbacks->GUI.Window.ClearProperty(g_interProcess.m_Handle, m_WindowHandle, key.c_str());
+  }
+  
+  int CWindow::GetListSize()
+  {
+    return g_interProcess.m_Callbacks->GUI.Window.GetListSize(g_interProcess.m_Handle, m_WindowHandle);
+  }
+  
+  void CWindow::ClearList()
+  {
+    g_interProcess.m_Callbacks->GUI.Window.ClearList(g_interProcess.m_Handle, m_WindowHandle);
+  }
+  
+  CListItem* CWindow::AddStringItem(const std::string& name, int itemPosition)
+  {
+    GUIHANDLE handle = g_interProcess.m_Callbacks->GUI.Window.AddStringItem(g_interProcess.m_Handle, m_WindowHandle, name.c_str(), itemPosition);
+    if (handle)
+      return new CListItem(handle);
+
+    fprintf(stderr, "libKODI_gui-ERROR: cGUIWindow Failed to get control on list ṕosition %i !!!\n", itemPosition);
+    return nullptr;
+  }
+
+  void CWindow::AddItem(CListItem *item, int itemPosition)
+  {
+    g_interProcess.m_Callbacks->GUI.Window.AddItem(g_interProcess.m_Handle, m_WindowHandle, item->m_ListItemHandle, itemPosition);
+  }
+
+  void CWindow::RemoveItem(int itemPosition)
+  {
+    g_interProcess.m_Callbacks->GUI.Window.RemoveItem(g_interProcess.m_Handle, m_WindowHandle, itemPosition);
+  }
+
+  void CWindow::RemoveItem(CListItem* item)
+  {
+    g_interProcess.m_Callbacks->GUI.Window.RemoveItemFile(g_interProcess.m_Handle, m_WindowHandle, item->m_ListItemHandle);
+  }
+
+  CListItem* CWindow::GetListItem(int listPos)
+  {
+    GUIHANDLE handle = g_interProcess.m_Callbacks->GUI.Window.GetListItem(g_interProcess.m_Handle, m_WindowHandle, listPos);
+    if (handle)
+      return new CListItem(handle);
+
+    fprintf(stderr, "libKODI_gui-ERROR: cGUIWindow Failed to get control on list ṕosition %i !!!\n", listPos);
+    return nullptr;
+  }
+
+  void CWindow::SetCurrentListPosition(int listPos)
+  {
+    g_interProcess.m_Callbacks->GUI.Window.SetCurrentListPosition(g_interProcess.m_Handle, m_WindowHandle, listPos);
+  }
+
+  int CWindow::GetCurrentListPosition()
+  {
+    return g_interProcess.m_Callbacks->GUI.Window.GetCurrentListPosition(g_interProcess.m_Handle, m_WindowHandle);
+  }
+
+  void CWindow::SetControlLabel(int controlId, const std::string& label)
+  {
+    g_interProcess.m_Callbacks->GUI.Window.SetControlLabel(g_interProcess.m_Handle, m_WindowHandle, controlId, label.c_str());
+  }
+
+  void CWindow::MarkDirtyRegion()
+  {
+    g_interProcess.m_Callbacks->GUI.Window.MarkDirtyRegion(g_interProcess.m_Handle, m_WindowHandle);
+  }
+
+  /*!
+   * Kodi to add-on override definition function to use if class becomes used
+   * independet.
+   */
+  void CWindow::SetIndependentCallbacks(
+    GUIHANDLE     cbhdl,
+    bool          (*CBOnInit)  (GUIHANDLE cbhdl),
+    bool          (*CBOnFocus) (GUIHANDLE cbhdl, int controlId),
+    bool          (*CBOnClick) (GUIHANDLE cbhdl, int controlId),
+    bool          (*CBOnAction)(GUIHANDLE cbhdl, int actionId))
+  {
+    if (!cbhdl ||
+        !CBOnInit || !CBOnFocus || !CBOnClick || !CBOnAction)
+    {
+        fprintf(stderr, "libKODI_gui-ERROR: SetIndependentCallbacks called with nullptr !!!\n");
+        return;
+    }
+
+    g_interProcess.m_Callbacks->GUI.Window.SetCallbacks(g_interProcess.m_Handle, m_WindowHandle, cbhdl,
+                              CBOnInit, CBOnFocus, CBOnClick, CBOnAction);
+  }
+
+  /*!
+   * Defined callback functions from Kodi to add-on, for use in parent / child system
+   * (is private)!
+   */
+
+  bool CWindow::OnInitCB(GUIHANDLE cbhdl)
+  {
+    return static_cast<CWindow*>(cbhdl)->OnInit();
+  }
+
+  bool CWindow::OnClickCB(GUIHANDLE cbhdl, int controlId)
+  {
+    return static_cast<CWindow*>(cbhdl)->OnClick(controlId);
+  }
+
+  bool CWindow::OnFocusCB(GUIHANDLE cbhdl, int controlId)
+  {
+    return static_cast<CWindow*>(cbhdl)->OnFocus(controlId);
+  }
+
+  bool CWindow::OnActionCB(GUIHANDLE cbhdl, int actionId)
+  {
+    return static_cast<CWindow*>(cbhdl)->OnAction(actionId);
+  }
+
+} /* namespace GUI */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/inputstream/AddonLib_InputStream.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/inputstream/AddonLib_InputStream.cpp
new file mode 100644
index 0000000000..fb2e3d4c4d
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/inputstream/AddonLib_InputStream.cpp
@@ -0,0 +1,54 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, inputstream/InputStream.hpp)
+
+#include <string>
+#include <stdarg.h>
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace InputStream
+{
+
+  kodi_codec GetCodecByName(const std::string &strCodecName)
+  {
+    kodi_codec codec;
+    g_interProcess.m_Callbacks->InputStream.get_codec_by_name(g_interProcess.m_Handle, strCodecName.c_str(), &codec);
+    return codec;
+  }
+
+  DemuxPacket* AllocateDemuxPacket(int iDataSize)
+  {
+    return g_interProcess.m_Callbacks->InputStream.allocate_demux_packet(g_interProcess.m_Handle, iDataSize);
+  }
+
+  void FreeDemuxPacket(DemuxPacket* pPacket)
+  {
+    g_interProcess.m_Callbacks->InputStream.free_demux_packet(g_interProcess.m_Handle, pPacket);
+  }
+
+} /* namespace InputStream */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/kodi-addon-sharedlibrary-api2-config.cmake.in b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/kodi-addon-sharedlibrary-api2-config.cmake.in
new file mode 100644
index 0000000000..b8e756ba1b
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/kodi-addon-sharedlibrary-api2-config.cmake.in
@@ -0,0 +1,35 @@
+# - kodi-addon-sharedlibrary config mode
+#
+# Defines the following variables:
+#  kodi-addon-sharedlibrary_FOUND        - true
+#  kodi-addon-sharedlibrary_API_LEVEL    - detected api level
+#  kodi-addon-sharedlibrary_VERSION      - version of the dev kit library found, e.g. 2.0.0
+#  kodi-addon-sharedlibrary_INCLUDE_DIRS - header directories with which to compile
+#  kodi-addon-sharedlibrary_LINKER_FLAGS - flags that must be passed to the linker
+#  kodi-addon-sharedlibrary_LIBRARIES    - names of the libraries with which to link
+#  kodi-addon-sharedlibrary_LIBRARY_DIRS - directories in which the libraries are situated
+#
+# propagate these properties from one build system to the other
+set (kodi-addon-sharedlibrary_API_LEVEL "2")
+set (kodi-addon-sharedlibrary_VERSION "2.0.0")
+set (kodi-addon-sharedlibrary_INCLUDE_DIRS @prefix@/include)
+set (kodi-addon-sharedlibrary_LIBRARY_DIRS "")
+set (kodi-addon-sharedlibrary_LINKER_FLAGS "")
+set (kodi-addon-sharedlibrary_CONFIG_VARS "")
+set (exec_prefix @exec_prefix@)
+
+# libraries come from the build tree where this file was generated
+if(WIN32)
+  set (kodi-addon-sharedlibrary_LIBRARY "@libdir@/kodi.addon.sharedlibrary.api2.lib")
+else(WIN32)
+  set (kodi-addon-sharedlibrary_LIBRARY "-L@libdir@ -lkodi.addon.sharedlibrary.api2")
+endif(WIN32)
+set (kodi-addon-sharedlibrary_LIBRARIES ${kodi-addon-sharedlibrary_LIBRARY})
+mark_as_advanced (kodi-addon-sharedlibrary_LIBRARY)
+
+# add the library as a target, so that other things in the project including
+# this file may depend on it and get rebuild if this library changes.
+add_library (kodi-addon-sharedlibrary UNKNOWN IMPORTED)
+set_property (TARGET kodi-addon-sharedlibrary PROPERTY IMPORTED_LOCATION "${kodi-addon-sharedlibrary_LIBRARY}")
+add_definitions(-DAPI_LEVELS_ACTIVE)
+add_definitions(-DUSE_KODI_API_LEVEL=${kodi-addon-sharedlibrary_API_LEVEL})
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/kodi-addon-sharedlibrary-api2.pc.in b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/kodi-addon-sharedlibrary-api2.pc.in
new file mode 100644
index 0000000000..6170cc0a9b
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/kodi-addon-sharedlibrary-api2.pc.in
@@ -0,0 +1,12 @@
+prefix=@prefix@
+libdir=@libdir@
+includedir=@includedir@
+CXX=@CXX@
+CC=@CC@
+DEPENDENCIES=
+
+Name: kodi-addon-sharedlibrary-api2
+Description: Kodi add-on API 2 development kit for shared libraries
+Version: 2.0.0
+Libs: -L${libdir} -lkodi.addon.sharedlibrary.api2
+Cflags: -I${includedir} @CXXFLAGS@
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/peripheral/AddonLib_Peripheral.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/peripheral/AddonLib_Peripheral.cpp
new file mode 100644
index 0000000000..815f976e7c
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/peripheral/AddonLib_Peripheral.cpp
@@ -0,0 +1,47 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, peripheral/Peripheral.hpp)
+
+#include <string>
+#include <stdarg.h>
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace Peripheral
+{
+
+  void TriggerScan(void)
+  {
+    g_interProcess.m_Callbacks->Peripheral.trigger_scan(g_interProcess.m_Handle);
+  }
+
+  void RefreshButtonMaps(const std::string& deviceName, const std::string& controllerId)
+  {
+    g_interProcess.m_Callbacks->Peripheral.refresh_button_maps(g_interProcess.m_Handle, deviceName.c_str(), controllerId.c_str());
+  }
+
+} /* namespace Peripheral */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/player/AddonLib_Player_InfoTagMusic.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/player/AddonLib_Player_InfoTagMusic.cpp
new file mode 100644
index 0000000000..c1e74a40db
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/player/AddonLib_Player_InfoTagMusic.cpp
@@ -0,0 +1,150 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, player/InfoTagMusic.hpp)
+#include KITINCLUDE(ADDON_API_LEVEL, player/Player.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+
+namespace Player
+{
+
+  CInfoTagMusic::CInfoTagMusic(CPlayer* player)
+  {
+    if (!player || !player->m_ControlHandle)
+    {
+      return;
+    }
+
+    AddonInfoTagMusic infoTag;
+    if (g_interProcess.m_Callbacks->AddonInfoTagMusic.GetFromPlayer(g_interProcess.m_Handle, player, &infoTag))
+    {
+      TransferInfoTag(infoTag);
+      g_interProcess.m_Callbacks->AddonInfoTagMusic.Release(g_interProcess.m_Handle, &infoTag);
+    }
+  }
+
+  CInfoTagMusic::~CInfoTagMusic()
+  {
+  }
+
+  const std::string& CInfoTagMusic::GetURL() const
+  {
+    return m_url;
+  }
+
+  const std::string& CInfoTagMusic::GetTitle() const
+  {
+    return m_title;
+  }
+
+  const std::string& CInfoTagMusic::GetArtist() const
+  {
+    return m_artist;
+  }
+
+  const std::string& CInfoTagMusic::GetAlbum() const
+  {
+    return m_album;
+  }
+
+  const std::string& CInfoTagMusic::GetAlbumArtist() const
+  {
+    return m_albumArtist;
+  }
+
+  const std::string& CInfoTagMusic::GetGenre() const
+  {
+    return m_genre;
+  }
+
+  int CInfoTagMusic::GetDuration() const
+  {
+    return m_duration;
+  }
+
+  int CInfoTagMusic::GetTrack() const
+  {
+    return m_tracks;
+  }
+
+  int CInfoTagMusic::GetDisc() const
+  {
+    return m_disc;
+  }
+
+  const std::string& CInfoTagMusic::GetReleaseDate() const
+  {
+    return m_releaseDate;
+  }
+
+  int CInfoTagMusic::GetListeners() const
+  {
+    return m_listener;
+  }
+
+  int CInfoTagMusic::GetPlayCount() const
+  {
+    return m_playCount;
+  }
+
+  const std::string& CInfoTagMusic::GetLastPlayed() const
+  {
+    return m_lastPlayed;
+  }
+
+  const std::string& CInfoTagMusic::GetComment() const
+  {
+    return m_comment;
+  }
+
+  const std::string& CInfoTagMusic::GetLyrics() const
+  {
+    return m_lyrics;
+  }
+
+  void CInfoTagMusic::TransferInfoTag(AddonInfoTagMusic& infoTag)
+  {
+    m_url = infoTag.m_url;
+    m_title = infoTag.m_title;
+    m_artist = infoTag.m_artist;
+    m_album = infoTag.m_album;
+    m_albumArtist = infoTag.m_albumArtist;
+    m_genre = infoTag.m_genre;
+    m_duration = infoTag.m_duration;
+    m_tracks = infoTag.m_tracks;
+    m_disc = infoTag.m_disc;
+    m_releaseDate = infoTag.m_releaseDate;
+    m_listener = infoTag.m_listener;
+    m_playCount = infoTag.m_playCount;
+    m_lastPlayed = infoTag.m_lastPlayed;
+    m_comment = infoTag.m_comment;
+    m_lyrics = infoTag.m_lyrics;
+  }
+
+
+} /* namespace Player */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/player/AddonLib_Player_InfoTagVideo.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/player/AddonLib_Player_InfoTagVideo.cpp
new file mode 100644
index 0000000000..3aa976d915
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/player/AddonLib_Player_InfoTagVideo.cpp
@@ -0,0 +1,204 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, player/InfoTagVideo.hpp)
+#include KITINCLUDE(ADDON_API_LEVEL, player/Player.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+
+namespace Player
+{
+
+  CInfoTagVideo::CInfoTagVideo(CPlayer* player)
+  {
+    if (!player || !player->m_ControlHandle)
+    {
+      return;
+    }
+
+    AddonInfoTagVideo infoTag;
+    if (g_interProcess.m_Callbacks->AddonInfoTagVideo.GetFromPlayer(g_interProcess.m_Handle, player, &infoTag))
+    {
+      TransferInfoTag(infoTag);
+      g_interProcess.m_Callbacks->AddonInfoTagVideo.Release(g_interProcess.m_Handle, &infoTag);
+    }
+  }
+
+  CInfoTagVideo::~CInfoTagVideo()
+  {
+  }
+
+  const std::string& CInfoTagVideo::GetDirector() const
+  {
+    return m_director;
+  }
+
+  const std::string& CInfoTagVideo::GetWritingCredits() const
+  {
+    return m_writingCredits;
+  }
+
+  const std::string& CInfoTagVideo::GetGenre() const
+  {
+    return m_genre;
+  }
+
+  const std::string& CInfoTagVideo::GetCountry() const
+  {
+    return m_country;
+  }
+
+  const std::string& CInfoTagVideo::GetTagLine() const
+  {
+    return m_tagLine;
+  }
+
+  const std::string& CInfoTagVideo::GetPlotOutline() const
+  {
+    return m_plotOutline;
+  }
+
+  const std::string& CInfoTagVideo::GetPlot() const
+  {
+    return m_plot;
+  }
+
+  const std::string& CInfoTagVideo::GetTrailer() const
+  {
+    return m_trailer;
+  }
+
+  const std::string& CInfoTagVideo::GetPictureURL() const
+  {
+    return m_pictureURL;
+  }
+
+  const std::string& CInfoTagVideo::GetTitle() const
+  {
+    return m_title;
+  }
+
+  const std::string& CInfoTagVideo::GetVotes() const
+  {
+    return m_votes;
+  }
+
+  const std::string& CInfoTagVideo::GetCast() const
+  {
+    return m_cast;
+  }
+
+  const std::string& CInfoTagVideo::GetFile() const
+  {
+    return m_file;
+  }
+
+  const std::string& CInfoTagVideo::GetPath() const
+  {
+    return m_path;
+  }
+
+  const std::string& CInfoTagVideo::GetIMDBNumber() const
+  {
+    return m_IMDBNumber;
+  }
+
+  const std::string& CInfoTagVideo::GetMPAARating() const
+  {
+    return m_MPAARating;
+  }
+
+  int CInfoTagVideo::GetYear() const
+  {
+    return m_year;
+  }
+
+  double CInfoTagVideo::GetRating() const
+  {
+    return m_rating;
+  }
+
+  int CInfoTagVideo::GetPlayCount() const
+  {
+    return m_playCount;
+  }
+
+  const std::string& CInfoTagVideo::GetLastPlayed() const
+  {
+    return m_lastPlayed;
+  }
+
+  const std::string& CInfoTagVideo::GetOriginalTitle() const
+  {
+    return m_originalTitle;
+  }
+
+  const std::string& CInfoTagVideo::GetPremiered() const
+  {
+    return m_premiered;
+  }
+
+  const std::string& CInfoTagVideo::GetFirstAired() const
+  {
+    return m_firstAired;
+  }
+
+  unsigned int CInfoTagVideo::GetDuration() const
+  {
+    return m_duration;
+  }
+
+  void CInfoTagVideo::TransferInfoTag(AddonInfoTagVideo& infoTag)
+  {
+    m_director = infoTag.m_director;
+    m_writingCredits = infoTag.m_writingCredits;
+    m_genre = infoTag.m_genre;
+    m_country = infoTag.m_country;
+    m_tagLine = infoTag.m_tagLine;
+    m_plotOutline = infoTag.m_plotOutline;
+    m_plot = infoTag.m_plot;
+    m_trailer = infoTag.m_trailer;
+    m_pictureURL = infoTag.m_pictureURL;
+    m_title = infoTag.m_title;
+    m_votes = infoTag.m_votes;
+    m_cast = infoTag.m_cast;
+    m_file = infoTag.m_file;
+    m_path = infoTag.m_path;
+    m_IMDBNumber = infoTag.m_IMDBNumber;
+    m_MPAARating = infoTag.m_MPAARating;
+    m_year = infoTag.m_year;
+    m_rating = infoTag.m_rating;
+    m_playCount = infoTag.m_playCount;
+    m_lastPlayed = infoTag.m_lastPlayed;
+    m_originalTitle = infoTag.m_originalTitle;
+    m_premiered = infoTag.m_premiered;
+    m_firstAired = infoTag.m_firstAired;
+    m_duration = infoTag.m_duration;
+  }
+
+
+} /* namespace Player */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/player/AddonLib_Player_PlayList.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/player/AddonLib_Player_PlayList.cpp
new file mode 100644
index 0000000000..08b5501184
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/player/AddonLib_Player_PlayList.cpp
@@ -0,0 +1,100 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, gui/ListItem.hpp)
+#include KITINCLUDE(ADDON_API_LEVEL, player/PlayList.hpp)
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+
+namespace Player
+{
+
+  CPlayList::CPlayList(AddonPlayListType playlist)
+   : m_ControlHandle(nullptr),
+     m_playlist(playlist)
+  {
+    m_ControlHandle = g_interProcess.m_Callbacks->AddonPlayList.New(g_interProcess.m_Handle, playlist);
+    if (!m_ControlHandle)
+      fprintf(stderr, "ERROR: CPlayList can't create control class from Kodi !!!\n");
+  }
+
+  CPlayList::~CPlayList()
+  {
+    g_interProcess.m_Callbacks->AddonPlayList.Delete(g_interProcess.m_Handle, m_ControlHandle);
+  }
+
+  AddonPlayListType CPlayList::GetPlayListType() const
+  {
+    return m_playlist;
+  }
+
+  bool CPlayList::LoadPlaylist(const std::string& filename)
+  {
+    return g_interProcess.m_Callbacks->AddonPlayList.LoadPlaylist(g_interProcess.m_Handle, m_ControlHandle, filename.c_str(), m_playlist);
+  }
+
+  void CPlayList::AddItem(const std::string& url, int index)
+  {
+    g_interProcess.m_Callbacks->AddonPlayList.AddItemURL(g_interProcess.m_Handle, m_ControlHandle, url.c_str(), index);
+  }
+
+  void CPlayList::AddItem(const API_NAMESPACE_NAME::KodiAPI::GUI::CListItem* listitem, int index)
+  {
+    g_interProcess.m_Callbacks->AddonPlayList.AddItemList(g_interProcess.m_Handle, m_ControlHandle, listitem->GetListItemHandle(), index);
+  }
+
+  void CPlayList::RemoveItem(const std::string& url)
+  {
+    g_interProcess.m_Callbacks->AddonPlayList.RemoveItem(g_interProcess.m_Handle, m_ControlHandle, url.c_str());
+  }
+
+  void CPlayList::ClearList()
+  {
+    g_interProcess.m_Callbacks->AddonPlayList.ClearList(g_interProcess.m_Handle, m_ControlHandle);
+  }
+
+  int CPlayList::GetListSize()
+  {
+    return g_interProcess.m_Callbacks->AddonPlayList.GetListSize(g_interProcess.m_Handle, m_ControlHandle);
+  }
+
+  int CPlayList::GetListPosition()
+  {
+    return g_interProcess.m_Callbacks->AddonPlayList.GetListPosition(g_interProcess.m_Handle, m_ControlHandle);
+  }
+
+  void CPlayList::Shuffle(bool shuffle)
+  {
+    g_interProcess.m_Callbacks->AddonPlayList.Shuffle(g_interProcess.m_Handle, m_ControlHandle, shuffle);
+  }
+
+  GUI::CListItem* CPlayList::operator [](long i)
+  {
+    return static_cast<GUI::CListItem*>(g_interProcess.m_Callbacks->AddonPlayList.GetItem(g_interProcess.m_Handle, m_ControlHandle, i));
+  }
+
+} /* namespace Player */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/player/AddonLib_Player_Player.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/player/AddonLib_Player_Player.cpp
new file mode 100644
index 0000000000..bcaa6f4783
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/player/AddonLib_Player_Player.cpp
@@ -0,0 +1,206 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, player/Player.hpp)
+
+#include <cstring>
+
+using namespace API_NAMESPACE_NAME::KodiAPI::GUI;
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+
+namespace Player
+{
+  CPlayer::CPlayer()
+  {
+    m_ControlHandle = g_interProcess.m_Callbacks->AddonPlayer.New(g_interProcess.m_Handle);
+    if (!m_ControlHandle)
+      fprintf(stderr, "ERROR: CPlayer can't create control class from Kodi !!!\n");
+  }
+
+  CPlayer::~CPlayer()
+  {
+    g_interProcess.m_Callbacks->AddonPlayer.Delete(g_interProcess.m_Handle, m_ControlHandle);
+  }
+
+  std::string CPlayer::GetSupportedMedia(AddonPlayListType mediaType)
+  {
+    std::string strReturn;
+    char* strMsg = g_interProcess.m_Callbacks->AddonPlayer.GetSupportedMedia(g_interProcess.m_Handle, mediaType);
+    if (strMsg != nullptr)
+    {
+      if (std::strlen(strMsg))
+        strReturn = strMsg;
+      g_interProcess.m_Callbacks->free_string(g_interProcess.m_Handle, strMsg);
+    }
+    return strReturn;
+  }
+
+  bool CPlayer::Play(const std::string& item, bool windowed)
+  {
+    return g_interProcess.m_Callbacks->AddonPlayer.PlayFile(g_interProcess.m_Handle, m_ControlHandle, item.c_str(), windowed);
+  }
+
+  bool CPlayer::Play(const CListItem *listitem, bool windowed)
+  {
+    return g_interProcess.m_Callbacks->AddonPlayer.PlayFileItem(g_interProcess.m_Handle, m_ControlHandle, listitem->GetListItemHandle(), windowed);
+  }
+
+  bool CPlayer::Play(const CPlayList *list, bool windowed, int startpos)
+  {
+    return g_interProcess.m_Callbacks->AddonPlayer.PlayList(g_interProcess.m_Handle, m_ControlHandle, list->GetListHandle(), list->GetListType(), windowed, startpos);
+  }
+
+  void CPlayer::Stop()
+  {
+    g_interProcess.m_Callbacks->AddonPlayer.Stop(g_interProcess.m_Handle, m_ControlHandle);
+  }
+
+  void CPlayer::Pause()
+  {
+    g_interProcess.m_Callbacks->AddonPlayer.Pause(g_interProcess.m_Handle, m_ControlHandle);
+  }
+
+  void CPlayer::PlayNext()
+  {
+    g_interProcess.m_Callbacks->AddonPlayer.PlayNext(g_interProcess.m_Handle, m_ControlHandle);
+  }
+
+  void CPlayer::PlayPrevious()
+  {
+    g_interProcess.m_Callbacks->AddonPlayer.PlayPrevious(g_interProcess.m_Handle, m_ControlHandle);
+  }
+
+  void CPlayer::PlaySelected(int selected)
+  {
+    g_interProcess.m_Callbacks->AddonPlayer.PlaySelected(g_interProcess.m_Handle, m_ControlHandle, selected);
+  }
+
+  bool CPlayer::IsPlaying()
+  {
+    return g_interProcess.m_Callbacks->AddonPlayer.IsPlaying(g_interProcess.m_Handle, m_ControlHandle);
+  }
+
+  bool CPlayer::IsPlayingAudio()
+  {
+    return g_interProcess.m_Callbacks->AddonPlayer.IsPlayingAudio(g_interProcess.m_Handle, m_ControlHandle);
+  }
+
+  bool CPlayer::IsPlayingVideo()
+  {
+    return g_interProcess.m_Callbacks->AddonPlayer.IsPlayingVideo(g_interProcess.m_Handle, m_ControlHandle);
+  }
+
+  bool CPlayer::IsPlayingRDS()
+  {
+    return g_interProcess.m_Callbacks->AddonPlayer.IsPlayingRDS(g_interProcess.m_Handle, m_ControlHandle);
+  }
+
+  bool CPlayer::GetPlayingFile(std::string& file)
+  {
+    file.resize(1024);
+    unsigned int size = (unsigned int)file.capacity();
+    bool ret = g_interProcess.m_Callbacks->AddonPlayer.GetPlayingFile(g_interProcess.m_Handle, m_ControlHandle, file[0], size);
+    file.resize(size);
+    file.shrink_to_fit();
+    return ret;
+  }
+
+  double CPlayer::GetTotalTime()
+  {
+    return g_interProcess.m_Callbacks->AddonPlayer.GetTotalTime(g_interProcess.m_Handle, m_ControlHandle);
+  }
+  
+  double CPlayer::GetTime()
+  {
+    return g_interProcess.m_Callbacks->AddonPlayer.GetTime(g_interProcess.m_Handle, m_ControlHandle);
+  }
+  
+  void CPlayer::SeekTime(double seekTime)
+  {
+    g_interProcess.m_Callbacks->AddonPlayer.SeekTime(g_interProcess.m_Handle, m_ControlHandle, seekTime);
+  }
+
+  bool CPlayer::GetAvailableAudioStreams(std::vector<std::string> &streams)
+  {
+    char** list;
+    unsigned int listSize = 0;
+    bool ret = g_interProcess.m_Callbacks->AddonPlayer.GetAvailableAudioStreams(g_interProcess.m_Handle, m_ControlHandle, list, listSize);
+    if (ret)
+    {
+      for (unsigned int i = 0; i < listSize; ++i)
+        streams.push_back(list[i]);
+      g_interProcess.m_Callbacks->AddonPlayer.ClearList(list, listSize);
+    }
+    return ret;
+  }
+
+  void CPlayer::SetAudioStream(int iStream)
+  {
+    g_interProcess.m_Callbacks->AddonPlayer.SetAudioStream(g_interProcess.m_Handle, m_ControlHandle, iStream);
+  }
+
+  bool CPlayer::GetAvailableSubtitleStreams(std::vector<std::string> &streams)
+  {
+    char** list;
+    unsigned int listSize = 0;
+    bool ret = g_interProcess.m_Callbacks->AddonPlayer.GetAvailableSubtitleStreams(g_interProcess.m_Handle, m_ControlHandle, list, listSize);
+    if (ret)
+    {
+      for (unsigned int i = 0; i < listSize; ++i)
+        streams.push_back(list[i]);
+      g_interProcess.m_Callbacks->AddonPlayer.ClearList(list, listSize);
+    }
+    return ret;
+  }
+
+  void CPlayer::SetSubtitleStream(int iStream)
+  {
+    g_interProcess.m_Callbacks->AddonPlayer.SetSubtitleStream(g_interProcess.m_Handle, m_ControlHandle, iStream);
+  }
+  
+  void CPlayer::ShowSubtitles(bool bVisible)
+  {
+    g_interProcess.m_Callbacks->AddonPlayer.ShowSubtitles(g_interProcess.m_Handle, m_ControlHandle, bVisible);
+  }
+
+  bool CPlayer::GetCurrentSubtitleName(std::string& name)
+  {
+    name.resize(1024);
+    unsigned int size = (unsigned int)name.capacity();
+    bool ret = g_interProcess.m_Callbacks->AddonPlayer.GetCurrentSubtitleName(g_interProcess.m_Handle, m_ControlHandle, name[0], size);
+    name.resize(size);
+    name.shrink_to_fit();
+    return ret;
+  }
+
+  void CPlayer::AddSubtitle(const std::string& subPath)
+  {
+    g_interProcess.m_Callbacks->AddonPlayer.AddSubtitle(g_interProcess.m_Handle, m_ControlHandle, subPath.c_str());
+  }
+
+} /* namespace Player */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/pvr/AddonLib_PVR_General.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/pvr/AddonLib_PVR_General.cpp
new file mode 100644
index 0000000000..484a3f797d
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/pvr/AddonLib_PVR_General.cpp
@@ -0,0 +1,60 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, pvr/General.hpp)
+
+#include <string>
+#include <stdarg.h>
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace PVR
+{
+namespace General
+{
+
+  void AddMenuHook(PVR_MENUHOOK* hook)
+  {
+    g_interProcess.m_Callbacks->PVR.add_menu_hook(g_interProcess.m_Handle, hook);
+  }
+
+  void Recording(const std::string& strRecordingName, const std::string& strFileName, bool bOn)
+  {
+    g_interProcess.m_Callbacks->PVR.recording(g_interProcess.m_Handle, strRecordingName.c_str(), strFileName.c_str(), bOn);
+  }
+
+  void ConnectionStateChange(const std::string& strConnectionString, PVR_CONNECTION_STATE newState, const std::string& strMessage)
+  {
+    g_interProcess.m_Callbacks->PVR.connection_state_change(g_interProcess.m_Handle, strConnectionString.c_str(), newState, strMessage.c_str());
+  }
+
+  void EpgEventStateChange(EPG_TAG *tag, unsigned int iUniqueChannelId, EPG_EVENT_STATE newState)
+  {
+    g_interProcess.m_Callbacks->PVR.epg_event_state_change(g_interProcess.m_Handle, tag, iUniqueChannelId, newState);
+  }
+
+} /* namespace General */
+} /* namespace PVR */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/pvr/AddonLib_PVR_Stream.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/pvr/AddonLib_PVR_Stream.cpp
new file mode 100644
index 0000000000..f76349dade
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/pvr/AddonLib_PVR_Stream.cpp
@@ -0,0 +1,210 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#define API_LEVELS_ACTIVE 1
+#include <time.h>
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, AddonLib.hpp)
+#include KITINCLUDE(ADDON_API_LEVEL, pvr/StreamUtils.hpp)
+
+#include <string>
+#include <stdarg.h>
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace PVR
+{
+
+  CPVRStream::CPVRStream()
+  {
+    Clear();
+  }
+
+  CPVRStream::CPVRStream(const CPVRStream &other)
+  {
+    memcpy(this, &other, sizeof(PVR_STREAM_PROPERTIES::PVR_STREAM));
+  }
+
+  CPVRStream& CPVRStream::operator=(const CPVRStream &other)
+  {
+    memcpy(this, &other, sizeof(PVR_STREAM_PROPERTIES::PVR_STREAM));
+    return *this;
+  }
+
+  bool CPVRStream::operator==(const CPVRStream &other) const
+  {
+    return iPID == other.iPID && iCodecId == other.iCodecId;
+  }
+
+  bool CPVRStream::operator<(const CPVRStream &other) const
+  {
+    if (iCodecType == API_NAMESPACE_NAME::KodiAPI::KODI_CODEC_TYPE_VIDEO)
+      return true;
+    else if (other.iCodecType != API_NAMESPACE_NAME::KodiAPI::KODI_CODEC_TYPE_VIDEO)
+      return iPID < other.iPID;
+    else
+      return false;
+  }
+
+  bool CPVRStream::IsCleared() const
+  {
+    return iCodecId   == KODI_INVALID_CODEC_ID &&
+           iCodecType == API_NAMESPACE_NAME::KodiAPI::KODI_CODEC_TYPE_UNKNOWN;
+  }
+
+  void CPVRStream::Clear()
+  {
+    memset(this, 0, sizeof(PVR_STREAM_PROPERTIES::PVR_STREAM));
+    iCodecId = KODI_INVALID_CODEC_ID;
+    iCodecType = API_NAMESPACE_NAME::KodiAPI::KODI_CODEC_TYPE_UNKNOWN;
+  }
+
+  /*\___________________________________________________________________________
+  \*/
+
+  CStreamProperties::CStreamProperties(void)
+  {
+    // make sure the vector won't have to resize itself later
+    m_streamVector = new stream_vector();
+    m_streamVector->reserve(PVR_STREAM_MAX_STREAMS);
+  }
+
+  CStreamProperties::~CStreamProperties(void)
+  {
+    delete m_streamVector;
+  }
+
+  void CStreamProperties::Clear(void)
+  {
+    m_streamVector->clear();
+    m_streamIndex.clear();
+  }
+
+  int CStreamProperties::GetStreamId(unsigned int iPID) const
+  {
+    std::map<unsigned int, int>::const_iterator it = m_streamIndex.find(iPID);
+    if (it != m_streamIndex.end())
+      return it->second;
+
+    return -1;
+  }
+
+  CPVRStream* CStreamProperties::GetStreamById(unsigned int iPID) const
+  {
+    int position = GetStreamId(iPID);
+    return position != -1 ? &m_streamVector->at(position) : NULL;
+  }
+
+  void CStreamProperties::GetStreamData(unsigned int iPID, CPVRStream* stream)
+  {
+    CPVRStream *foundStream = GetStreamById(iPID);
+    if (foundStream)
+      *stream = *foundStream;
+    else
+    {
+      stream->iSubtitleInfo = -1;
+      stream->iPID = iPID;
+    }
+  }
+
+  bool CStreamProperties::GetProperties(PVR_STREAM_PROPERTIES* props)
+  {
+    unsigned int i = 0;
+    for (stream_vector::const_iterator it = m_streamVector->begin();
+         it != m_streamVector->end(); ++it, ++i)
+    {
+      memcpy(&props->stream[i], &(*it), sizeof(PVR_STREAM_PROPERTIES::PVR_STREAM));
+    }
+
+    props->iStreamCount = m_streamVector->size();
+    return (props->iStreamCount > 0);
+  }
+
+  void CStreamProperties::UpdateStreams(stream_vector &newStreams)
+  {
+    // sort the new streams
+    std::sort(newStreams.begin(), newStreams.end());
+
+    // ensure we never have more than PVR_STREAMS_MAX_STREAMS streams
+    if (newStreams.size() > PVR_STREAM_MAX_STREAMS)
+    {
+      while (newStreams.size() > PVR_STREAM_MAX_STREAMS)
+        newStreams.pop_back();
+
+      KodiAPI::Log(ADDON_LOG_ERROR, "%s - max amount of streams reached", __FUNCTION__);
+    }
+
+    stream_vector::iterator newStreamPosition;
+    for (stream_vector::iterator it = m_streamVector->begin(); it != m_streamVector->end(); ++it)
+    {
+      newStreamPosition = std::find(newStreams.begin(), newStreams.end(), *it);
+
+      // if the current stream no longer exists we clear it, otherwise we
+      // copy it and remove it from newStreams
+      if (newStreamPosition == newStreams.end())
+        it->Clear();
+      else
+      {
+        *it = *newStreamPosition;
+        newStreams.erase(newStreamPosition);
+      }
+    }
+
+    // replace cleared streams with new streams
+    for (stream_vector::iterator it = m_streamVector->begin();
+         it != m_streamVector->end() && !newStreams.empty(); ++it)
+    {
+      if (it->IsCleared())
+      {
+        *it = newStreams.front();
+        newStreams.erase(newStreams.begin());
+      }
+    }
+
+    // append any remaining new streams
+    m_streamVector->insert(m_streamVector->end(), newStreams.begin(), newStreams.end());
+
+    // remove trailing cleared streams
+    while (m_streamVector->back().IsCleared())
+      m_streamVector->pop_back();
+
+    // update the index
+    UpdateIndex();
+  }
+
+  /**
+   * Updates the stream index
+   */
+  void CStreamProperties::UpdateIndex()
+  {
+    m_streamIndex.clear();
+
+    int i = 0;
+    for (stream_vector::const_iterator it = m_streamVector->begin(); it != m_streamVector->end(); ++it, ++i)
+      m_streamIndex[it->iPID] = i;
+  }
+
+
+} /* namespace PVR */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/pvr/AddonLib_PVR_Transfer.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/pvr/AddonLib_PVR_Transfer.cpp
new file mode 100644
index 0000000000..b49e234dc6
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/pvr/AddonLib_PVR_Transfer.cpp
@@ -0,0 +1,70 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, pvr/Transfer.hpp)
+
+#include <string>
+#include <stdarg.h>
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace PVR
+{
+namespace Transfer
+{
+
+  void EpgEntry(const ADDON_HANDLE handle, const EPG_TAG* entry)
+  {
+    g_interProcess.m_Callbacks->PVR.transfer_epg_entry(g_interProcess.m_Handle, handle, entry);
+  }
+
+  void ChannelEntry(const ADDON_HANDLE handle, const PVR_CHANNEL* entry)
+  {
+    g_interProcess.m_Callbacks->PVR.transfer_channel_entry(g_interProcess.m_Handle, handle, entry);
+  }
+
+  void TimerEntry(const ADDON_HANDLE handle, const PVR_TIMER* entry)
+  {
+    g_interProcess.m_Callbacks->PVR.transfer_timer_entry(g_interProcess.m_Handle, handle, entry);
+  }
+
+  void RecordingEntry(const ADDON_HANDLE handle, const PVR_RECORDING* entry)
+  {
+    g_interProcess.m_Callbacks->PVR.transfer_recording_entry(g_interProcess.m_Handle, handle, entry);
+  }
+
+  void ChannelGroup(const ADDON_HANDLE handle, const PVR_CHANNEL_GROUP* entry)
+  {
+    g_interProcess.m_Callbacks->PVR.transfer_channel_group(g_interProcess.m_Handle, handle, entry);
+  }
+
+  void ChannelGroupMember(const ADDON_HANDLE handle, const PVR_CHANNEL_GROUP_MEMBER* entry)
+  {
+    g_interProcess.m_Callbacks->PVR.transfer_channel_group_member(g_interProcess.m_Handle, handle, entry);
+  }
+
+} /* namespace Transfer */
+} /* namespace PVR */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/pvr/AddonLib_PVR_Trigger.cpp b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/pvr/AddonLib_PVR_Trigger.cpp
new file mode 100644
index 0000000000..bed5e4c6ef
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/kodi-addon-sharedlibrary/pvr/AddonLib_PVR_Trigger.cpp
@@ -0,0 +1,65 @@
+/*
+ *      Copyright (C) 2016 Team KODI
+ *      http://kodi.tv
+ *
+ *  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 KODI; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "InterProcess.h"
+#include KITINCLUDE(ADDON_API_LEVEL, pvr/Trigger.hpp)
+
+#include <string>
+#include <stdarg.h>
+
+API_NAMESPACE
+
+namespace KodiAPI
+{
+namespace PVR
+{
+namespace Trigger
+{
+
+  void TimerUpdate(void)
+  {
+    g_interProcess.m_Callbacks->PVR.trigger_timer_update(g_interProcess.m_Handle);
+  }
+
+  void RecordingUpdate(void)
+  {
+    g_interProcess.m_Callbacks->PVR.trigger_recording_update(g_interProcess.m_Handle);
+  }
+
+  void ChannelUpdate(void)
+  {
+    g_interProcess.m_Callbacks->PVR.trigger_channel_update(g_interProcess.m_Handle);
+  }
+
+  void EpgUpdate(unsigned int iChannelUid)
+  {
+    g_interProcess.m_Callbacks->PVR.trigger_epg_update(g_interProcess.m_Handle, iChannelUid);
+  }
+
+  void ChannelGroupsUpdate(void)
+  {
+    g_interProcess.m_Callbacks->PVR.trigger_channel_groups_update(g_interProcess.m_Handle);
+  }
+
+} /* namespace Trigger */
+} /* namespace PVR */
+} /* namespace KodiAPI */
+
+END_NAMESPACE()
diff --git a/xbmc/addons/kodi-addon-dev-kit/src/api2/version.h b/xbmc/addons/kodi-addon-dev-kit/src/api2/version.h
new file mode 100644
index 0000000000..67c30e5fef
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/src/api2/version.h
@@ -0,0 +1,10 @@
+#pragma once
+
+/*
+ * Addon <-> Kodi interface system API level and version. Used on level
+ * parts and inside Kodi.
+ *
+ * Used this way to have easy compatible on all OS systems.
+ */
+#define ADDON_API_LEVEL   2
+#define ADDON_API_VERSION "2.0.0"
diff --git a/xbmc/addons/kodi-addon-dev-kit/tools/rename-apilevel-number.py b/xbmc/addons/kodi-addon-dev-kit/tools/rename-apilevel-number.py
new file mode 100755
index 0000000000..9c64154e50
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/tools/rename-apilevel-number.py
@@ -0,0 +1,73 @@
+#!/usr/bin/python
+
+#
+#      Copyright (C) 2016 Team KODI
+#      http://kodi.tv
+#
+#  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 KODI; see the file COPYING.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+from optparse import OptionParser
+import os, sys
+
+# cannot be loaded as a module
+if __name__ != "__main__":
+    sys.stderr.write('This file cannot be loaded as a module!')
+    sys.exit()
+
+# parse command-line options
+disc = """
+This utility rename the string 'api*' with new defined level number on all
+files with path defined header source.
+
+Is to have on a API level change all doxygen related documentation comments
+with right number.
+
+Example:
+./rename-apilevel-number.py --source=../include/kodi/api3 --old_level=2 --new_level=3
+"""
+
+parser = OptionParser(description=disc)
+parser.add_option('--source', dest='source', metavar='DIR',
+                  help='the source folder where changes becomes done [required]')
+parser.add_option('--old_level', dest='old_level', metavar='NUMBER',
+                  help='old level number which becomes changes [required]')
+parser.add_option('--new_level', dest='new_level', metavar='NUMBER',
+                  help='new level number which becomes used [required]')
+(options, args) = parser.parse_args()
+
+# the header option is required
+if options.source is None or options.old_level is None or options.new_level is None:
+    parser.print_help(sys.stdout)
+    sys.exit()
+
+def replace_word(infile,old_word,new_word):
+    if not os.path.isfile(infile):
+        print ("Error on replace_word, not a regular file: " + infile)
+        sys.exit(1)
+
+    f1=open(infile,'r').read()
+    f2=open(infile,'w')
+    m=f1.replace(old_word,new_word)
+    f2.write(m)
+
+print 'Renaming on all files in "' + options.source + '" the text from "api' + options.old_level + '" to "api' + options.new_level + '"'
+
+from os.path import join, getsize
+for root, dirs, files in os.walk(options.source):
+    for file in files:
+        print root + '/' + file
+        replace_word(root + '/' + file, 'api' + options.old_level, 'api' + options.new_level)