From 8c794964442901127b73050b34b17902aee50be2 Mon Sep 17 00:00:00 2001
From: Zachary Christiansen <volfan6415@gmail.com>
Date: Wed, 6 May 2020 00:04:56 -0500
Subject: [PATCH 1/3] *add played indicator config option *add additional
 control options *various bug fixes and code cleanup to prepare for pull
 request

Signed-off-by: Zachary Christiansen <volfan6415@gmail.com>
---
 bundles/org.openhab.binding.emby/.classpath   |  32 ++
 bundles/org.openhab.binding.emby/.project     |  23 ++
 bundles/org.openhab.binding.emby/NOTICE       |  13 +
 bundles/org.openhab.binding.emby/README.md    |  69 ++++
 bundles/org.openhab.binding.emby/pom.xml      |  16 +
 .../src/main/feature/feature.xml              |   9 +
 .../emby/internal/EmbyBindingConstants.java   |  80 ++++
 .../internal/EmbyBridgeConfiguration.java     |  95 +++++
 .../emby/internal/EmbyBridgeListener.java     |  32 ++
 .../internal/EmbyDeviceConfiguration.java     |  24 ++
 .../emby/internal/EmbyEventListener.java      |  84 +++++
 .../emby/internal/EmbyHandlerFactory.java     | 134 +++++++
 .../discovery/EmbyClientDiscoveryService.java | 100 +++++
 .../discovery/EmbyDiscoveryService.java       | 204 ++++++++++
 .../internal/handler/EmbyBridgeHandler.java   | 159 ++++++++
 .../internal/handler/EmbyDeviceHandler.java   | 356 ++++++++++++++++++
 .../internal/model/EmbyNowPlayingItem.java    |  82 ++++
 .../emby/internal/model/EmbyPlayState.java    |  69 ++++
 .../internal/model/EmbyPlayStateModel.java    | 188 +++++++++
 .../model/EmbyPlayingPostJsonModel.java       |  93 +++++
 .../internal/protocol/EmbyClientSocket.java   | 245 ++++++++++++
 .../EmbyClientSocketEventListener.java        |  31 ++
 .../internal/protocol/EmbyConnection.java     | 108 ++++++
 .../internal/protocol/EmbyDeviceEncoder.java  |  32 ++
 .../emby/internal/protocol/EmbyHTTPUtils.java |  94 +++++
 .../protocol/EmbyHttpRetryExceeded.java       |  25 ++
 .../resources/ESH-INF/binding/binding.xml     |  10 +
 .../resources/ESH-INF/thing/thing-types.xml   | 195 ++++++++++
 bundles/pom.xml                               |   4 +-
 29 files changed, 2604 insertions(+), 2 deletions(-)
 create mode 100644 bundles/org.openhab.binding.emby/.classpath
 create mode 100644 bundles/org.openhab.binding.emby/.project
 create mode 100644 bundles/org.openhab.binding.emby/NOTICE
 create mode 100644 bundles/org.openhab.binding.emby/README.md
 create mode 100644 bundles/org.openhab.binding.emby/pom.xml
 create mode 100644 bundles/org.openhab.binding.emby/src/main/feature/feature.xml
 create mode 100644 bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyBindingConstants.java
 create mode 100644 bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyBridgeConfiguration.java
 create mode 100644 bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyBridgeListener.java
 create mode 100644 bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyDeviceConfiguration.java
 create mode 100644 bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyEventListener.java
 create mode 100644 bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyHandlerFactory.java
 create mode 100644 bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/discovery/EmbyClientDiscoveryService.java
 create mode 100644 bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/discovery/EmbyDiscoveryService.java
 create mode 100644 bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/handler/EmbyBridgeHandler.java
 create mode 100644 bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/handler/EmbyDeviceHandler.java
 create mode 100644 bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyNowPlayingItem.java
 create mode 100644 bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyPlayState.java
 create mode 100644 bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyPlayStateModel.java
 create mode 100644 bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyPlayingPostJsonModel.java
 create mode 100644 bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyClientSocket.java
 create mode 100644 bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyClientSocketEventListener.java
 create mode 100644 bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyConnection.java
 create mode 100644 bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyDeviceEncoder.java
 create mode 100644 bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyHTTPUtils.java
 create mode 100644 bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyHttpRetryExceeded.java
 create mode 100644 bundles/org.openhab.binding.emby/src/main/resources/ESH-INF/binding/binding.xml
 create mode 100644 bundles/org.openhab.binding.emby/src/main/resources/ESH-INF/thing/thing-types.xml

diff --git a/bundles/org.openhab.binding.emby/.classpath b/bundles/org.openhab.binding.emby/.classpath
new file mode 100644
index 0000000000000..a5d95095ccaaf
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/.classpath
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" output="target/classes" path="src/main/java">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+			<attribute name="test" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="output" path="target/classes"/>
+</classpath>
diff --git a/bundles/org.openhab.binding.emby/.project b/bundles/org.openhab.binding.emby/.project
new file mode 100644
index 0000000000000..fd1181c0281bd
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/.project
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.openhab.binding.emby</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+	</natures>
+</projectDescription>
diff --git a/bundles/org.openhab.binding.emby/NOTICE b/bundles/org.openhab.binding.emby/NOTICE
new file mode 100644
index 0000000000000..38d625e349232
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/NOTICE
@@ -0,0 +1,13 @@
+This content is produced and maintained by the openHAB project.
+
+* Project home: https://www.openhab.org
+
+== Declared Project Licenses
+
+This program and the accompanying materials are made available under the terms
+of the Eclipse Public License 2.0 which is available at
+https://www.eclipse.org/legal/epl-2.0/.
+
+== Source Code
+
+https://github.com/openhab/openhab-addons
diff --git a/bundles/org.openhab.binding.emby/README.md b/bundles/org.openhab.binding.emby/README.md
new file mode 100644
index 0000000000000..0ed08706609f2
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/README.md
@@ -0,0 +1,69 @@
+# Emby Binding
+
+The Emby Binding integrates EMBY  support with openHAB, allowing both controlling the player as well as retrieving player status data like the currently played movie title.
+
+This binding supports multiple clients connected to a EMBY Media Server. This binding allows simlar integration and control in the same manner as the Plex Binding. For example with this binding, it's possible to dim your lights when a video starts playing. 
+
+## Supported Things
+
+_Please describe the different supported things / devices within this section._
+_Which different types are supported, which models were tested etc.?_
+_Note that it is planned to generate some part of this based on the XML files within ```ESH-INF/thing``` of your binding._
+
+## Discovery
+
+The binding will autodiscover all clients which are conneted to your EMBY media server.  These clients will be added to the inbox after the first time they come online and begin playing media.  This however only works once a connection to an EMBY media server has been established by creating the bridge thing type for the EMBY media server.
+
+
+## Thing Configuration
+
+There are two types of things for this binding.  The bridge type and the device.  The bridge must be created before any device types will be generated.
+
+The bridge should be configured as follows:
+
+| Parameter | Description                                              |
+|---------|----------------------------------------------------------|
+| API Key       | This is the API key generated from EMBY used for Authorization. (Generated from your emby server at Dashboard -> Expert -> Advanced -> Security)                           |
+| Web Socket Buffer Size       | Here you can define a custom size for the websocket buffer size. Default is 100000. Increasing this can descrease server timeouts in certain cases |
+| ipAddress       | This is the ip address of the EMBY Server. |
+| Port       | This is the port of the EMBY server. |
+| Refresh Parameter       | This is the refresh interval in milliseconds that will be sent to the websocket. |
+
+## Channels
+
+An emby device that is automatically discovered will come with several preconfigured channels:
+
+| Channel Type | Item Type            | Config Parameters                                  | Description                                                                                                                                                                                                                                   |
+|--------------|----------------------|----------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Control | Player            | None                                  | This channel will indicate the playing status of the device. It can also be used to send play/pause commands                                                                                                                                                                                                                                   |
+| Stop | Switch            | None                                  | This channel will indicate whether there is media currently playing on the device.  When media is playing the channel will indicate ON.  Sending a command of OFF to the channel will send a command to stop any currently playing media.                                                                                                                                                                                                                                     |
+| Title | String            | None                                  | Will show the title of the currently playing song                                                                                                                                                                                                                                   |
+| Mute | Switch            | None                                  | Indicates whether the device is muted.  Sending a command of ON will send a mute command to the currently playing media.                                                                                                                                                                                                                                   |
+| ShowTitle | String            | None                                  | Will show the title of the currently playing movie or TV show.                                                                                                                                                                                                                                   |
+| Image URL | String            | Image Max Height
+                                  Image Max Width
+                                  Image Type
+                                  Percent Played                                  | This will produce a URL to the currently playing media. More information about the config parameters can be found at https://github.com/MediaBrowser/Emby/wiki/Images.                                                                                                                                                                                                                                   |
+| Current Time | Number:Time            | None                                  | The current play time of the playing media.                                                                                                                                                                                                                                   |
+| Duration | Number:Time            | None                                  | The length of time left in the current playing media item.                                                                                                                                                                                                                                   |
+| Media Type | String            | None                                  | Description                                                                                                                                                                                                                                   |
+| Send Play | String            | None                                  | Description                                                                                                                                                                                                                                   |
+
+
+## Full Example
+
+*.things 
+*.items
+String EMBYWMCPosterImage_URL "URL: [%s]" (EMBY) {channel="emby:device:416bcb51:d96138c30b0b404cba7513ae09db7966:imageurl"}
+String EMBYWMCTVStatus      "Status [%s]"   <video>  (EMBY)
+Switch EMBYWMC_HTPC_Stop (EMBY,EMBY_HTPC_Stop){channel="emby:device:416bcb51:d96138c30b0b404cba7513ae09db7966:stop"}
+String EMBYWMCItemPlayed "[%s]" (EMBY) {channel="emby:device:416bcb51:d96138c30b0b404cba7513ae09db7966:showtitle" }
+Switch EMBYWMC_IsMute (EMBY, EMBY_IsMute){channel="emby:device:416bcb51:d96138c30b0b404cba7513ae09db7966:mute"}
+Player EMBYWMC_Player (EMBY) {channel="emby:device:416bcb51:d96138c30b0b404cba7513ae09db7966:control"} 
+
+*.sitemap
+Image     item=EMBYWMCPosterImage_URL      label=""
+
+
+
+
diff --git a/bundles/org.openhab.binding.emby/pom.xml b/bundles/org.openhab.binding.emby/pom.xml
new file mode 100644
index 0000000000000..d5410ee8856bb
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/pom.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+
+  <modelVersion>4.0.0</modelVersion>
+
+  <parent>
+    <groupId>org.openhab.addons.bundles</groupId>
+    <artifactId>org.openhab.addons.reactor.bundles</artifactId>
+    <version>2.5.5-SNAPSHOT</version>
+  </parent>
+
+  <artifactId>org.openhab.binding.emby</artifactId>
+
+  <name>openHAB Add-ons :: Bundles :: Emby Binding</name>
+
+</project>
diff --git a/bundles/org.openhab.binding.emby/src/main/feature/feature.xml b/bundles/org.openhab.binding.emby/src/main/feature/feature.xml
new file mode 100644
index 0000000000000..7deb9ffe307a3
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/src/main/feature/feature.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<features name="org.openhab.binding.emby-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.4.0">
+    <repository>mvn:org.openhab.core.features.karaf/org.openhab.core.features.karaf.openhab-core/${ohc.version}/xml/features</repository>
+
+    <feature name="openhab-binding-emby" description="Emby Binding" version="${project.version}">
+        <feature>openhab-runtime-base</feature>
+        <bundle start-level="80">mvn:org.openhab.addons.bundles/org.openhab.binding.emby/${project.version}</bundle>
+    </feature>
+</features>
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyBindingConstants.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyBindingConstants.java
new file mode 100644
index 0000000000000..cf68e7df6d996
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyBindingConstants.java
@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.emby.internal;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.smarthome.core.thing.ThingTypeUID;
+
+/**
+ * The {@link EmbyBindingConstants} class defines common constants, which are
+ * used across the whole binding.
+ *
+ * @author Zachary Christiansen - Initial contribution
+ */
+@NonNullByDefault
+public class EmbyBindingConstants {
+
+    private static final String BINDING_ID = "emby";
+
+    // List of all Thing Type UIDs
+    public static final ThingTypeUID THING_TYPE_EMBY_CONTROLLER = new ThingTypeUID(BINDING_ID, "controller");
+    public static final ThingTypeUID THING_TYPE_EMBY_DEVICE = new ThingTypeUID(BINDING_ID, "device");
+
+    // List of all Channel ids
+    public static final String CHANNEL_MUTE = "mute";
+    public static final String CHANNEL_VOLUME = "volume";
+    public static final String CHANNEL_STOP = "stop";
+    public static final String CHANNEL_CONTROL = "control";
+    public static final String CHANNEL_SENDPLAYCOMMAND = "sendplay";
+    public static final String CHANNEL_GENERALCOMMAND = "generalCommand";
+    public static final String CHANNEL_GENERALCOMMANDWITHARGS = "generalCommand_withArguments";
+
+    public static final String CHANNEL_GENERALCOMMAND_NAME = "generalCommand_CommandName";
+
+    public static final String CHANNEL_TITLE = "title";
+    public static final String CHANNEL_SHOWTITLE = "showtitle";
+
+    public static final String CHANNEL_MEDIATYPE = "mediatype";
+
+    public static final String CHANNEL_CURRENTTIME = "currenttime";
+
+    public static final String CHANNEL_DURATION = "duration";
+    public static final String CHANNEL_IMAGEURL = "imageurl";
+    public static final String CHANNEL_IMAGEURL_TYPE = "imageurl_type";
+    public static final String CHANNEL_IMAGEURL_MAXWIDTH = "imageurl_maxWidth";
+    public static final String CHANNEL_IMAGEURL_MAXHEIGHT = "imageurl_maxHeight";
+    public static final String CHANNEL_IMAGEURL_PERCENTPLAYED = "imageurl_PercentPlayed";
+
+    // Module Properties
+
+    public static final String HOST_PARAMETER = "ipAddress";
+    public static final String WS_PORT_PARAMETER = "port";
+    public static final String WS_BUFFER_SIZE = "buffer_size";
+    public static final String HTTP_PORT_PARAMETER = "httpPort";
+    public static final String HTTP_USER_PARAMETER = "httpUser";
+    public static final String HTTP_PASSWORD_PARAMETER = "httpPassword";
+    public static final String REFRESH_PARAMETER = "refreshInterval";
+    public static final String API_KEY = "api";
+    public static final String DEVICE_ID = "deviceID";
+
+    // control constant commands
+    public static final String CONTROL_SESSION = "/Sessions/";
+    public static final String CONTROL_GENERALCOMMAND = "/Command/";
+    public static final String CONTROL_SENDPLAY = "/Playing";
+    public static final String CONTROL_PLAY = "/Playing/Unpause";
+    public static final String CONTROL_PAUSE = "/Playing/Pause";
+    public static final String CONTROL_MUTE = "/Command/Mute";
+    public static final String CONTROL_UNMUTE = "/Command/Unmute";
+    public static final String CONTROL_STOP = "/Playing/Stop";
+
+}
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyBridgeConfiguration.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyBridgeConfiguration.java
new file mode 100644
index 0000000000000..ffebf797bd725
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyBridgeConfiguration.java
@@ -0,0 +1,95 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.emby.internal;
+
+/**
+ * The {@link EmbyBridgeConfiguration} class contains fields mapping thing configuration parameters.
+ *
+ * @author Zachary Christiansen - Initial contribution
+ */
+public class EmbyBridgeConfiguration {
+
+    public String api;
+
+    private String ipAddress;
+    private Integer port;
+    private Integer httpPort;
+    private Integer refreshInterval;
+    private Integer notificationTimeout;
+    private Integer notificationVolume;
+
+    public String getIpAddress() {
+        return ipAddress;
+    }
+
+    public void setIpAddress(String ipAddress) {
+        this.ipAddress = ipAddress;
+    }
+
+    public Integer getPort() {
+        return port;
+    }
+
+    public void setPort(Integer port) {
+        this.port = port;
+    }
+
+    public Integer getHttpPort() {
+        return httpPort;
+    }
+
+    public void setHttpPort(Integer httpPort) {
+        this.httpPort = httpPort;
+    }
+
+    /*
+     * public String getHttpUser() {
+     * return httpUser;
+     * }
+     *
+     * public void setHttpUser(String httpUser) {
+     * this.httpUser = httpUser;
+     * }
+     *
+     * public String getHttpPassword() {
+     * return httpPassword;
+     * }
+     *
+     * public void setHttpPassword(String httpPassword) {
+     * this.httpPassword = httpPassword;
+     * }
+     */
+    public Integer getRefreshInterval() {
+        return refreshInterval;
+    }
+
+    public void setRefreshInterval(Integer refreshInterval) {
+        this.refreshInterval = refreshInterval;
+    }
+
+    public Integer getNotificationTimeout() {
+        return notificationTimeout;
+    }
+
+    public void setNotificationTimeout(Integer notificationTimeout) {
+        this.notificationTimeout = notificationTimeout;
+    }
+
+    public Integer getNotificationVolume() {
+        return notificationVolume;
+    }
+
+    public void setNotificationVolume(Integer notificationVolume) {
+        this.notificationVolume = notificationVolume;
+    }
+}
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyBridgeListener.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyBridgeListener.java
new file mode 100644
index 0000000000000..b3542b2389ad9
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyBridgeListener.java
@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.emby.internal;
+
+import java.util.EventListener;
+
+import org.openhab.binding.emby.internal.model.EmbyPlayStateModel;
+import org.openhab.binding.emby.internal.protocol.EmbyConnection;
+
+/**
+ * Interface which has to be implemented by a class in order to get status
+ * updates from a {@link EmbyConnection}
+ *
+ * @author Zachary Christiansen - Initial Contribution
+ */
+public interface EmbyBridgeListener extends EventListener {
+
+    void updateConnectionState(boolean connected);
+
+    void handleEvent(EmbyPlayStateModel playstate, String hostname, int embyport);
+
+}
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyDeviceConfiguration.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyDeviceConfiguration.java
new file mode 100644
index 0000000000000..2948001ea93f8
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyDeviceConfiguration.java
@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.emby.internal;
+
+/**
+ * The {@link EmbyDeviceConfiguration} class contains fields mapping thing configuration parameters.
+ *
+ * @author Zachary Christiansen - Initial contribution
+ */
+public class EmbyDeviceConfiguration {
+
+    public String deviceID;
+
+}
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyEventListener.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyEventListener.java
new file mode 100644
index 0000000000000..698dd9a37bed5
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyEventListener.java
@@ -0,0 +1,84 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.emby.internal;
+
+import java.util.EventListener;
+
+import org.openhab.binding.emby.internal.model.EmbyPlayStateModel;
+import org.openhab.binding.emby.internal.protocol.EmbyConnection;
+
+/**
+ * Interface which has to be implemented by a class in order to get status
+ * updates from a {@link EmbyConnection}
+ *
+ * @author Zachary Christiansen - Initial Contribution
+ */
+public interface EmbyEventListener extends EventListener {
+    public enum EmbyState {
+        PLAY,
+        PAUSE,
+        END,
+        STOP,
+        REWIND,
+        FASTFORWARD
+    }
+
+    public enum EmbyPlaylistState {
+        ADD,
+        ADDED,
+        INSERT,
+        REMOVE,
+        REMOVED,
+        CLEAR
+    }
+
+    void updateConnectionState(boolean connected);
+
+    void updateScreenSaverState(boolean screenSaveActive);
+
+    // void updatePlaylistState(EmbyPlaylistState playlistState);
+
+    // void updateVolume(int volume);
+
+    void updatePlayerState(EmbyState state);
+
+    void updateMuted(boolean muted);
+
+    void updateTitle(String title);
+
+    void updateShowTitle(String title);
+
+    // void updateAlbum(String album);
+
+    // void updateArtistList(List<String> artistList);
+
+    void updateMediaType(String mediaType);
+
+    // void updateGenreList(List<String> genreList);
+
+    // void updatePVRChannel(final String channel);
+
+    // void updateThumbnail(RawType thumbnail);
+
+    // void updateFanart(RawType fanart);
+
+    void updateCurrentTime(long currentTime);
+
+    // void updateCurrentTimePercentage(double currentTimePercentage);
+
+    void updateDuration(long duration);
+
+    void updatePrimaryImageURL(String imageURL);
+
+    public void handleEvent(EmbyPlayStateModel playstate, String hostname, int embyport);
+}
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyHandlerFactory.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyHandlerFactory.java
new file mode 100644
index 0000000000000..42cba5746612c
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyHandlerFactory.java
@@ -0,0 +1,134 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.emby.internal;
+
+import static org.openhab.binding.emby.internal.EmbyBindingConstants.*;
+
+import java.util.Collections;
+import java.util.Dictionary;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.smarthome.config.discovery.DiscoveryService;
+import org.eclipse.smarthome.core.net.HttpServiceUtil;
+import org.eclipse.smarthome.core.net.NetworkAddressService;
+import org.eclipse.smarthome.core.thing.Bridge;
+import org.eclipse.smarthome.core.thing.Thing;
+import org.eclipse.smarthome.core.thing.ThingTypeUID;
+import org.eclipse.smarthome.core.thing.ThingUID;
+import org.eclipse.smarthome.core.thing.binding.BaseThingHandlerFactory;
+import org.eclipse.smarthome.core.thing.binding.ThingHandler;
+import org.eclipse.smarthome.core.thing.binding.ThingHandlerFactory;
+import org.openhab.binding.emby.internal.discovery.EmbyClientDiscoveryService;
+import org.openhab.binding.emby.internal.handler.EmbyBridgeHandler;
+import org.openhab.binding.emby.internal.handler.EmbyDeviceHandler;
+import org.osgi.framework.ServiceRegistration;
+import org.osgi.service.component.ComponentContext;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Reference;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * The {@link EmbyHandlerFactory} is responsible for creating things and thing
+ * handlers.
+ *
+ * @author Zachary Christiansen - Initial contribution
+ */
+@Component(configurationPid = "binding.emby", service = ThingHandlerFactory.class)
+public class EmbyHandlerFactory extends BaseThingHandlerFactory {
+
+    private Logger logger = LoggerFactory.getLogger(EmbyHandlerFactory.class);
+
+    private NetworkAddressService networkAddressService;
+
+    private static final Set<ThingTypeUID> SUPPORTED_THING_TYPES_UIDS = Collections
+            .unmodifiableSet(Stream.of(THING_TYPE_EMBY_CONTROLLER, THING_TYPE_EMBY_DEVICE).collect(Collectors.toSet()));
+    private String callbackUrl = null;
+    private final Map<ThingUID, @Nullable ServiceRegistration<?>> discoveryServiceRegs = new HashMap<>();
+
+    @Override
+    public boolean supportsThingType(ThingTypeUID thingTypeUID) {
+        return SUPPORTED_THING_TYPES_UIDS.contains(thingTypeUID);
+    }
+
+    @Override
+    protected @Nullable ThingHandler createHandler(Thing thing) {
+        ThingTypeUID thingTypeUID = thing.getThingTypeUID();
+        if (thingTypeUID.equals(THING_TYPE_EMBY_DEVICE)) {
+            return new EmbyDeviceHandler(thing);
+        } else if (thingTypeUID.equals(THING_TYPE_EMBY_CONTROLLER)) {
+            EmbyBridgeHandler bridgeHandler = new EmbyBridgeHandler((Bridge) thing, createCallbackUrl(),
+                    createCallbackPort());
+            registerEmbyClientDiscoveryService(bridgeHandler);
+            return bridgeHandler;
+        }
+        return null;
+    }
+
+    private String createCallbackUrl() {
+        if (callbackUrl != null) {
+            return callbackUrl;
+        } else {
+            final String ipAddress = networkAddressService.getPrimaryIpv4HostAddress();
+            if (ipAddress == null) {
+                logger.warn("No network interface could be found.");
+                return null;
+            }
+            return ipAddress;
+        }
+    }
+
+    private String createCallbackPort() {
+        // we do not use SSL as it can cause certificate validation issues.
+        final int port = HttpServiceUtil.getHttpServicePort(bundleContext);
+        if (port == -1) {
+            logger.warn("Cannot find port of the http service.");
+            return null;
+        }
+        return Integer.toString(port);
+    }
+
+    @Override
+    public void unregisterHandler(Thing thing) {
+        super.unregisterHandler(thing);
+    }
+
+    @Reference
+    protected void setNetworkAddressService(NetworkAddressService networkAddressService) {
+        this.networkAddressService = networkAddressService;
+    }
+
+    protected void unsetNetworkAddressService(NetworkAddressService networkAddressService) {
+        this.networkAddressService = null;
+    }
+
+    @Override
+    protected void activate(ComponentContext componentContext) {
+        super.activate(componentContext);
+        Dictionary<String, Object> properties = componentContext.getProperties();
+        callbackUrl = (String) properties.get("callbackUrl");
+    }
+
+    private synchronized void registerEmbyClientDiscoveryService(EmbyBridgeHandler bridgeHandler) {
+        EmbyClientDiscoveryService discoveryService = new EmbyClientDiscoveryService(bridgeHandler);
+        discoveryService.activate();
+        this.discoveryServiceRegs.put(bridgeHandler.getThing().getUID(), bundleContext
+                .registerService(DiscoveryService.class.getName(), discoveryService, new Hashtable<String, Object>()));
+    }
+}
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/discovery/EmbyClientDiscoveryService.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/discovery/EmbyClientDiscoveryService.java
new file mode 100644
index 0000000000000..f45269c607b13
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/discovery/EmbyClientDiscoveryService.java
@@ -0,0 +1,100 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.emby.internal.discovery;
+
+import static org.openhab.binding.emby.internal.EmbyBindingConstants.*;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.smarthome.config.discovery.AbstractDiscoveryService;
+import org.eclipse.smarthome.config.discovery.DiscoveryResult;
+import org.eclipse.smarthome.config.discovery.DiscoveryResultBuilder;
+import org.eclipse.smarthome.config.discovery.DiscoveryService;
+import org.eclipse.smarthome.core.thing.ThingTypeUID;
+import org.eclipse.smarthome.core.thing.ThingUID;
+import org.openhab.binding.emby.internal.handler.EmbyBridgeHandler;
+import org.openhab.binding.emby.internal.model.EmbyPlayStateModel;
+import org.openhab.binding.emby.internal.protocol.EmbyDeviceEncoder;
+import org.osgi.service.component.annotations.Component;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * The {@EmbyClientDiscoveryService} handles the discovery of devices which are playing media on an emby server which
+ * has been setup as a bridge. This discovery service receives events from the corresponding {@EmbyBridgeHandler} that
+ * it is attached to
+ *
+ * @author Zachary Christiansen - Initial contribution
+ */
+@Component(service = DiscoveryService.class, immediate = true, configurationPid = "discovery.emby")
+public class EmbyClientDiscoveryService extends AbstractDiscoveryService {
+    private final Logger logger = LoggerFactory.getLogger(EmbyClientDiscoveryService.class);
+    private static final Set<ThingTypeUID> SUPPORTED_THING_TYPES_UIDS = Collections.singleton(THING_TYPE_EMBY_DEVICE);
+
+    private final EmbyBridgeHandler embyBridgeHandler;
+
+    public EmbyClientDiscoveryService() {
+        super(SUPPORTED_THING_TYPES_UIDS, 10, false);
+        this.embyBridgeHandler = null;
+    }
+
+    public EmbyClientDiscoveryService(EmbyBridgeHandler embyBridgeHandler) {
+        super(SUPPORTED_THING_TYPES_UIDS, 10, true);
+        this.embyBridgeHandler = embyBridgeHandler;
+    }
+
+    public void activate() {
+        embyBridgeHandler.registerDeviceFoundListener(this);
+    }
+
+    @Override
+    public void startScan() {
+        // this discovery service does not do any scanning all of the scanning is handled by the bridge handler and
+        // passed in to this service
+    }
+
+    public void addDeviceIDDiscover(EmbyPlayStateModel playstate) {
+        logger.debug("adding new emby device");
+        ThingUID thingUID = getThingUID(playstate);
+        ThingTypeUID thingTypeUID = THING_TYPE_EMBY_DEVICE;
+        EmbyDeviceEncoder encode = new EmbyDeviceEncoder();
+        String modelId = encode.encodeDeviceID(playstate.getDeviceId());
+        if (thingUID != null && modelId != null) {
+            ThingUID bridgeUID = embyBridgeHandler.getThing().getUID();
+            Map<String, Object> properties = new HashMap<>(1);
+            properties.put(DEVICE_ID, modelId);
+            logger.debug("Disovered device {} with id {}", playstate.getDeviceName(), modelId);
+            DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID).withThingType(thingTypeUID)
+                    .withProperties(properties).withBridge(bridgeUID).withRepresentationProperty(DEVICE_ID)
+                    .withLabel(playstate.getDeviceName()).build();
+            thingDiscovered(discoveryResult);
+        } else {
+            logger.debug("discovered unsupported device of type '{}' and model '{}' with id {}",
+                    playstate.getDeviceName(), modelId, playstate.getDeviceId());
+        }
+    }
+
+    private @Nullable ThingUID getThingUID(EmbyPlayStateModel playstate) {
+        ThingUID bridgeUID = embyBridgeHandler.getThing().getUID();
+        ThingTypeUID thingTypeUID = THING_TYPE_EMBY_DEVICE;
+        if (playstate.getDeviceId() != null) {
+            return new ThingUID(thingTypeUID, bridgeUID, playstate.getDeviceId());
+        } else {
+            return null;
+        }
+    }
+}
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/discovery/EmbyDiscoveryService.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/discovery/EmbyDiscoveryService.java
new file mode 100644
index 0000000000000..9e95d4f019cdd
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/discovery/EmbyDiscoveryService.java
@@ -0,0 +1,204 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.emby.internal.discovery;
+
+import static org.openhab.binding.emby.internal.EmbyBindingConstants.*;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+import java.net.InterfaceAddress;
+import java.net.NetworkInterface;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.smarthome.config.discovery.AbstractDiscoveryService;
+import org.eclipse.smarthome.config.discovery.DiscoveryResult;
+import org.eclipse.smarthome.config.discovery.DiscoveryResultBuilder;
+import org.eclipse.smarthome.config.discovery.DiscoveryService;
+import org.eclipse.smarthome.core.thing.ThingTypeUID;
+import org.eclipse.smarthome.core.thing.ThingUID;
+import org.openhab.binding.emby.internal.protocol.EmbyDeviceEncoder;
+import org.osgi.service.component.annotations.Activate;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Deactivate;
+import org.osgi.service.component.annotations.Modified;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonObject;
+
+/**
+ * The {@EmbyDiscoveryService} handles the bridge discovery which find emby servers on the network
+ *
+ * @author Zachary Christiansen - Initial contribution
+ */
+@NonNullByDefault
+@Component(service = DiscoveryService.class, immediate = true, configurationPid = "discovery.emby")
+public class EmbyDiscoveryService extends AbstractDiscoveryService {
+
+    private static final String REQUEST_MSG = "who is EmbyServer?";
+    private static final int REQUEST_PORT = 7359;
+
+    private final Logger logger = LoggerFactory.getLogger(EmbyDiscoveryService.class);
+    private static final Set<ThingTypeUID> SUPPORTED_THING_TYPES_UIDS = Collections
+            .singleton(THING_TYPE_EMBY_CONTROLLER);
+
+    public EmbyDiscoveryService() {
+        super(SUPPORTED_THING_TYPES_UIDS, 30, false);
+    }
+
+    @Activate
+    @Override
+    protected void activate(@Nullable Map<String, @Nullable Object> configProperties) {
+        super.activate(configProperties);
+    }
+
+    @Modified
+    @Override
+    protected void modified(@Nullable Map<String, @Nullable Object> configProperties) {
+        super.modified(configProperties);
+    }
+
+    @Deactivate
+    @Override
+    protected void deactivate() {
+        super.deactivate();
+    }
+
+    @Override
+    public void startScan() {
+        // Find the server using UDP broadcast
+        try {
+            // Open a random port to send the package
+            DatagramSocket c = new DatagramSocket();
+            c.setBroadcast(true);
+
+            byte[] sendData = REQUEST_MSG.getBytes();
+
+            // Try the 255.255.255.255 first
+            try {
+                DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length,
+                        InetAddress.getByName("255.255.255.255"), REQUEST_PORT);
+                c.send(sendPacket);
+                logger.debug(">>> Request packet sent to: {} ({})", REQUEST_MSG, REQUEST_PORT);
+            } catch (Exception e) {
+            }
+
+            // Broadcast the message over all the network interfaces
+            Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
+            while (interfaces.hasMoreElements()) {
+                NetworkInterface networkInterface = interfaces.nextElement();
+
+                if (networkInterface.isLoopback() || !networkInterface.isUp()) {
+                    continue; // Don't want to broadcast to the loopback interface
+                }
+
+                for (InterfaceAddress interfaceAddress : networkInterface.getInterfaceAddresses()) {
+                    InetAddress broadcast = interfaceAddress.getBroadcast();
+                    if (broadcast == null) {
+                        continue;
+                    }
+
+                    // Send the broadcast package!
+                    try {
+                        DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, broadcast,
+                                REQUEST_PORT);
+                        c.send(sendPacket);
+                    } catch (Exception e) {
+                    }
+
+                    logger.debug(">>> Request packet sent to: {} ; Interface: {}  ", broadcast.getHostAddress(),
+                            networkInterface.getDisplayName());
+                }
+            }
+
+            logger.debug(">>> Done looping over all network interfaces. Now waiting for a reply!");
+
+            // Wait for a response
+            byte[] recvBuf = new byte[15000];
+            DatagramPacket receivePacket = new DatagramPacket(recvBuf, recvBuf.length);
+            c.receive(receivePacket);
+
+            // We have a response
+            logger.debug(">>> Broadcast response from server:{}", receivePacket.getAddress().getHostAddress());
+
+            // Check if the message is correct
+            String message = new String(receivePacket.getData()).trim();
+
+            logger.debug("The message is {}", message);
+
+            // DO SOMETHING WITH THE SERVER'S IP (for example, store it in your controller)
+            receivePacket.getAddress();
+
+            Gson gson = new Gson();
+
+            JsonObject body = gson.fromJson(message, JsonObject.class);
+            String serverId = body.get("Id").getAsString();
+            String serverName = body.get("Name").getAsString();
+            String serverAddress = body.get("Address").getAsString();
+            EmbyDeviceEncoder encode = new EmbyDeviceEncoder();
+            serverId = encode.encodeDeviceID(serverId);
+            try {
+                URI serverAddressURI = new URI(serverAddress);
+                addEMBYServer(serverAddressURI.getHost(), serverAddressURI.getPort(), serverId, serverName);
+            } catch (URISyntaxException e) {
+                logger.debug("unable to parse URI from Emby server address: {}", e.getMessage());
+            }
+
+            // Close the port!
+            c.close();
+        } catch (IOException ex) {
+            logger.debug("The exception was: {}", ex.getMessage());
+        }
+    }
+
+    public void addEMBYServer(String hostAddress, int embyPort, String DeviceID, String Name) {
+        logger.debug("creating discovery result with address: {}:{}, for server {}", hostAddress,
+                Integer.toString(embyPort), Name);
+        ThingUID thingUID = getThingUID(DeviceID);
+        ThingTypeUID thingTypeUID = THING_TYPE_EMBY_CONTROLLER;
+
+        if (thingUID != null && DeviceID != null) {
+            Map<String, Object> properties = new HashMap<>();
+            properties.put(DEVICE_ID, DeviceID);
+            properties.put(HOST_PARAMETER, hostAddress);
+            properties.put(WS_PORT_PARAMETER, Integer.toString(embyPort));
+
+            DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID).withThingType(thingTypeUID)
+                    .withProperties(properties).withRepresentationProperty(DEVICE_ID).withLabel(Name).build();
+
+            thingDiscovered(discoveryResult);
+        } else {
+            logger.debug("Unable to add {} found at {}:{} with id of {}", Name, hostAddress, embyPort, DeviceID);
+        }
+    }
+
+    private @Nullable ThingUID getThingUID(String DeviceID) {
+        ThingTypeUID thingTypeUID = THING_TYPE_EMBY_CONTROLLER;
+        if (DeviceID != null) {
+            return new ThingUID(thingTypeUID, DeviceID);
+        } else {
+            return null;
+        }
+    }
+}
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/handler/EmbyBridgeHandler.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/handler/EmbyBridgeHandler.java
new file mode 100644
index 0000000000000..41310a41e25c7
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/handler/EmbyBridgeHandler.java
@@ -0,0 +1,159 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.emby.internal.handler;
+
+import static org.openhab.binding.emby.internal.EmbyBindingConstants.*;
+
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+
+import org.eclipse.smarthome.core.thing.Bridge;
+import org.eclipse.smarthome.core.thing.ChannelUID;
+import org.eclipse.smarthome.core.thing.ThingStatus;
+import org.eclipse.smarthome.core.thing.ThingStatusDetail;
+import org.eclipse.smarthome.core.thing.binding.BaseBridgeHandler;
+import org.eclipse.smarthome.core.types.Command;
+import org.openhab.binding.emby.internal.EmbyBridgeConfiguration;
+import org.openhab.binding.emby.internal.EmbyBridgeListener;
+import org.openhab.binding.emby.internal.discovery.EmbyClientDiscoveryService;
+import org.openhab.binding.emby.internal.model.EmbyPlayStateModel;
+import org.openhab.binding.emby.internal.protocol.EmbyConnection;
+import org.openhab.binding.emby.internal.protocol.EmbyHTTPUtils;
+import org.openhab.binding.emby.internal.protocol.EmbyHttpRetryExceeded;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * The {@link EmbyBridgeHandler} is responsible for handling commands, which are
+ * sent to one of the channels.
+ *
+ * @author Zachary Christiansen - Initial contribution
+ */
+
+public class EmbyBridgeHandler extends BaseBridgeHandler implements EmbyBridgeListener {
+
+    private final Logger logger = LoggerFactory.getLogger(EmbyBridgeHandler.class);
+
+    private EmbyBridgeConfiguration config;
+    private volatile EmbyConnection connection; // volatile because accessed from multiple threads
+    private ScheduledFuture<?> connectionCheckerFuture;
+    private String callbackIpAddress = null;
+    private EmbyClientDiscoveryService clientDiscoverySerivce;
+    private EmbyHTTPUtils httputils;
+
+    public EmbyBridgeHandler(Bridge bridge, String hostAddress, String port) {
+        super(bridge);
+        connection = new EmbyConnection(this);
+        callbackIpAddress = hostAddress + ":" + port;
+        logger.debug("The callback ip address is: {}", callbackIpAddress);
+
+        httputils = new EmbyHTTPUtils(30, (String) this.getConfig().get(API_KEY), getServerAddress());
+    }
+
+    public void sendCommand(String commandURL, String payload) {
+        try {
+            httputils.doPost(commandURL, payload, 2);
+        } catch (EmbyHttpRetryExceeded e) {
+            logger.debug("The number of retry attempts was exceeded", e.getCause());
+        }
+    }
+
+    public void sendCommand(String commandURL) {
+        try {
+            httputils.doPost(commandURL, "", 2);
+        } catch (EmbyHttpRetryExceeded e) {
+            logger.debug("The number of retry attempts was exceeded", e.getCause());
+        }
+    }
+
+    private String getServerAddress() {
+        String host = getConfig().get(HOST_PARAMETER).toString();
+        String port = Integer.toString(getIntConfigParameter(WS_PORT_PARAMETER, 8096));
+
+        return host + ":" + port;
+    }
+
+    private int getIntConfigParameter(String key, int defaultValue) {
+        Object obj = this.getConfig().get(key);
+        if (obj instanceof Number) {
+            return ((Number) obj).intValue();
+        } else if (obj instanceof String) {
+            return Integer.parseInt(obj.toString());
+        }
+        return defaultValue;
+    }
+
+    @Override
+    public void initialize() {
+        config = getConfigAs(EmbyBridgeConfiguration.class);
+        updateStatus(ThingStatus.UNKNOWN);
+        // Example for background initialization:
+        scheduler.execute(() -> {
+            try {
+                String host = getConfig().get(HOST_PARAMETER).toString();
+                if (host == null || host.isEmpty()) {
+                    updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR,
+                            "No network address specified");
+                } else {
+                    connection.connect(host, getIntConfigParameter(WS_PORT_PARAMETER, 8096),
+                            (String) this.getConfig().get(API_KEY), scheduler,
+                            getIntConfigParameter(REFRESH_PARAMETER, 10000),
+                            getIntConfigParameter(WS_BUFFER_SIZE, 100000));
+
+                    connectionCheckerFuture = scheduler.scheduleWithFixedDelay(() -> {
+                        if (!(connection.checkConnection())) {
+                            updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR,
+                                    "Connection could not be established");
+                        }
+                    }, 1, getIntConfigParameter(REFRESH_PARAMETER, 10), TimeUnit.SECONDS);
+                }
+            } catch (Exception e) {
+                logger.debug("error during opening connection: {}", e.getMessage(), e);
+                updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, e.getLocalizedMessage());
+            }
+        });
+    }
+
+    @Override
+    public void handleEvent(EmbyPlayStateModel playstate, String hostname, int embyport) {
+        logger.debug("Received event from emby server");
+        this.clientDiscoverySerivce.addDeviceIDDiscover(playstate);
+        this.getThing().getThings().forEach(thing -> {
+            EmbyDeviceHandler handler = (EmbyDeviceHandler) thing.getHandler();
+            logger.debug("Checking to see if handler is null");
+            if (!(handler == null)) {
+                handler.handleEvent(playstate, hostname, embyport);
+            } else {
+                logger.debug("There is no handler for thing {}", thing.getLabel());
+            }
+        });
+    }
+
+    @Override
+    public void updateConnectionState(boolean connected) {
+        if (connected) {
+            updateStatus(ThingStatus.ONLINE);
+        } else {
+            updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, "No connection established");
+        }
+    }
+
+    public void registerDeviceFoundListener(EmbyClientDiscoveryService embyClientDiscoverySerice) {
+        this.clientDiscoverySerivce = embyClientDiscoverySerice;
+    }
+
+    @Override
+    public void handleCommand(ChannelUID channelUID, Command command) {
+        logger.debug("The bridge handler is read only");
+    }
+}
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/handler/EmbyDeviceHandler.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/handler/EmbyDeviceHandler.java
new file mode 100644
index 0000000000000..24ef95bc4c5f8
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/handler/EmbyDeviceHandler.java
@@ -0,0 +1,356 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.emby.internal.handler;
+
+import static org.eclipse.smarthome.core.thing.ThingStatus.OFFLINE;
+import static org.eclipse.smarthome.core.thing.ThingStatusDetail.*;
+import static org.openhab.binding.emby.internal.EmbyBindingConstants.*;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import javax.measure.Unit;
+
+import org.eclipse.smarthome.config.core.Configuration;
+import org.eclipse.smarthome.core.library.types.OnOffType;
+import org.eclipse.smarthome.core.library.types.PlayPauseType;
+import org.eclipse.smarthome.core.library.types.QuantityType;
+import org.eclipse.smarthome.core.library.types.RawType;
+import org.eclipse.smarthome.core.library.types.RewindFastforwardType;
+import org.eclipse.smarthome.core.library.types.StringType;
+import org.eclipse.smarthome.core.library.unit.SmartHomeUnits;
+import org.eclipse.smarthome.core.thing.Bridge;
+import org.eclipse.smarthome.core.thing.Channel;
+import org.eclipse.smarthome.core.thing.ChannelUID;
+import org.eclipse.smarthome.core.thing.Thing;
+import org.eclipse.smarthome.core.thing.ThingStatus;
+import org.eclipse.smarthome.core.thing.ThingStatusDetail;
+import org.eclipse.smarthome.core.thing.binding.BaseThingHandler;
+import org.eclipse.smarthome.core.types.Command;
+import org.eclipse.smarthome.core.types.State;
+import org.eclipse.smarthome.core.types.UnDefType;
+import org.openhab.binding.emby.internal.EmbyDeviceConfiguration;
+import org.openhab.binding.emby.internal.EmbyEventListener;
+import org.openhab.binding.emby.internal.model.EmbyPlayStateModel;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * The {@link EmbyDeviceHandler} is responsible for handling commands, which are
+ * sent to one of the channels.
+ *
+ * @author Zachary Christiansen - Initial contribution
+ */
+
+public class EmbyDeviceHandler extends BaseThingHandler implements EmbyEventListener {
+
+    private final Logger logger = LoggerFactory.getLogger(EmbyDeviceHandler.class);
+
+    private EmbyDeviceConfiguration config;
+    private EmbyPlayStateModel currentPlayState = null;
+
+    public EmbyDeviceHandler(Thing thing) {
+        super(thing);
+    }
+
+    @Override
+    public void handleCommand(ChannelUID channelUID, Command command) {
+        // if we are in an active playstate then processs the command
+        Channel channel = this.thing.getChannel(channelUID.getId());
+        String commandName;
+        if (!(this.currentPlayState == null)) {
+            EmbyBridgeHandler handler = (EmbyBridgeHandler) this.getBridge().getHandler();
+            switch (channelUID.getId()) {
+                case CHANNEL_CONTROL:
+                    if (command instanceof PlayPauseType) {
+                        // if we are unpause
+                        if (PlayPauseType.PLAY.equals(command)) {
+                            handler.sendCommand(CONTROL_SESSION + currentPlayState.getId() + CONTROL_PLAY);
+                            // send the pause command
+                        } else {
+                            handler.sendCommand(CONTROL_SESSION + currentPlayState.getId() + CONTROL_PAUSE);
+                        }
+                    } else {
+                        logger.debug("The channel {} receceived a command {}, this command not supported",
+                                channelUID.getAsString(), command.toString());
+                    }
+                    break;
+                case CHANNEL_MUTE:
+                    if (OnOffType.ON.equals(command)) {
+                        handler.sendCommand(CONTROL_SESSION + currentPlayState.getId() + CONTROL_MUTE);
+                    } else {
+                        handler.sendCommand(CONTROL_SESSION + currentPlayState.getId() + CONTROL_UNMUTE);
+                    }
+                    break;
+                case CHANNEL_STOP:
+                    if (OnOffType.ON.equals(command)) {
+                        handler.sendCommand(CONTROL_SESSION + currentPlayState.getId() + CONTROL_STOP);
+                    }
+                    break;
+
+                case CHANNEL_SENDPLAYCOMMAND:
+                    logger.debug("Sending the following payload: {} for device: {}", command.toString(),
+                            currentPlayState.getId());
+                    handler.sendCommand(CONTROL_SESSION + currentPlayState.getId() + CONTROL_SENDPLAY,
+                            command.toString());
+                    break;
+
+                case CHANNEL_GENERALCOMMAND:
+                    commandName = channel.getConfiguration().get(CHANNEL_GENERALCOMMAND_NAME).toString();
+                    logger.debug("Sending the following command {} for device: {}", commandName,
+                            currentPlayState.getId());
+                    if (OnOffType.ON.equals(command)) {
+                        handler.sendCommand(
+                                CONTROL_SESSION + currentPlayState.getId() + CONTROL_GENERALCOMMAND + commandName);
+                    }
+                    break;
+                case CHANNEL_GENERALCOMMANDWITHARGS:
+                    commandName = channel.getConfiguration().get(CHANNEL_GENERALCOMMAND_NAME).toString();
+                    logger.debug("Sending the following command {} for device: {}", commandName,
+                            currentPlayState.getId());
+                    handler.sendCommand(
+                            CONTROL_SESSION + currentPlayState.getId() + CONTROL_GENERALCOMMAND + commandName,
+                            "Arguments:" + command + "}");
+                    break;
+            }
+        }
+    }
+
+    @Override
+    public void initialize() {
+        logger.debug("Initializing emby device: {}", this.getThing().getLabel());
+        config = getConfigAs(EmbyDeviceConfiguration.class);
+        updateStatus(ThingStatus.UNKNOWN);
+        Bridge bridge = getBridge();
+        if (bridge == null || bridge.getHandler() == null || !(bridge.getHandler() instanceof EmbyBridgeHandler)) {
+            updateStatus(OFFLINE, CONFIGURATION_ERROR, "You must choose a Emby Server for this Device.");
+            return;
+        }
+
+        if (bridge.getStatus() == OFFLINE) {
+            updateStatus(OFFLINE, BRIDGE_OFFLINE, "The Emby Server is currently offline.");
+            return;
+        }
+        updateStatus(ThingStatus.ONLINE);
+    }
+
+    @Override
+    public void updateConnectionState(boolean connected) {
+        if (connected) {
+            updateStatus(ThingStatus.ONLINE);
+        } else {
+            updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, "No connection established");
+        }
+    }
+
+    @Override
+    public void updateScreenSaverState(boolean screenSaveActive) {
+    }
+
+    @Override
+    public void updatePlayerState(EmbyState state) {
+        switch (state) {
+            case PLAY:
+                updateState(CHANNEL_CONTROL, PlayPauseType.PLAY);
+                updateState(CHANNEL_STOP, OnOffType.OFF);
+                break;
+            case PAUSE:
+                updateState(CHANNEL_CONTROL, PlayPauseType.PAUSE);
+                updateState(CHANNEL_STOP, OnOffType.OFF);
+                break;
+            case STOP:
+            case END:
+                updateState(CHANNEL_CONTROL, PlayPauseType.PAUSE);
+                updateState(CHANNEL_STOP, OnOffType.ON);
+                break;
+            case FASTFORWARD:
+                updateState(CHANNEL_CONTROL, RewindFastforwardType.FASTFORWARD);
+                updateState(CHANNEL_STOP, OnOffType.OFF);
+                break;
+            case REWIND:
+                updateState(CHANNEL_CONTROL, RewindFastforwardType.REWIND);
+                updateState(CHANNEL_STOP, OnOffType.OFF);
+                break;
+        }
+    }
+
+    @Override
+    public void updateMuted(boolean muted) {
+        if (muted) {
+            updateState(CHANNEL_MUTE, OnOffType.ON);
+        } else {
+            updateState(CHANNEL_MUTE, OnOffType.OFF);
+        }
+    }
+
+    @Override
+    public void updateTitle(String title) {
+        updateState(CHANNEL_TITLE, createStringState(title));
+    }
+
+    @Override
+    public void updatePrimaryImageURL(String imageUrl) {
+        updateState(CHANNEL_IMAGEURL, createStringState(imageUrl));
+    }
+
+    @Override
+    public void updateShowTitle(String title) {
+        updateState(CHANNEL_SHOWTITLE, createStringState(title));
+    }
+
+    @Override
+    public void updateMediaType(String mediaType) {
+        updateState(CHANNEL_MEDIATYPE, createStringState(mediaType));
+    }
+
+    @Override
+    public void updateCurrentTime(long currentTime) {
+        updateState(CHANNEL_CURRENTTIME, createQuantityState(currentTime, SmartHomeUnits.SECOND));
+    }
+
+    @Override
+    public void updateDuration(long duration) {
+        updateState(CHANNEL_DURATION, createQuantityState(duration, SmartHomeUnits.SECOND));
+    }
+
+    /**
+     * Wrap the given String in a new {@link StringType} or returns {@link UnDefType#UNDEF} if the String is empty.
+     */
+    private State createStringState(String string) {
+        if (string == null || string.isEmpty()) {
+            return UnDefType.UNDEF;
+        } else {
+            return new StringType(string);
+        }
+    }
+
+    /**
+     * Wrap the given list of Strings in a new {@link StringType} or returns {@link UnDefType#UNDEF} if the list of
+     * Strings is empty.
+     */
+    private State createStringListState(List<String> list) {
+        if (list == null || list.isEmpty()) {
+            return UnDefType.UNDEF;
+        } else {
+            return createStringState(list.stream().collect(Collectors.joining(", ")));
+        }
+    }
+
+    /**
+     * Wrap the given RawType and return it as {@link State} or return {@link UnDefType#UNDEF} if the RawType is null.
+     */
+    private State createImageState(RawType image) {
+        if (image == null) {
+            return UnDefType.UNDEF;
+        } else {
+            return image;
+        }
+    }
+
+    private State createQuantityState(Number value, Unit<?> unit) {
+        return (value == null) ? UnDefType.UNDEF : new QuantityType<>(value, unit);
+    }
+
+    private void updateState(EmbyState state) {
+        updatePlayerState(state);
+
+        // if this is a Stop then clear everything else
+        if (state == EmbyState.STOP) {
+            updateTitle("");
+            updateShowTitle("");
+            updatePrimaryImageURL("");
+            updateMediaType("");
+            updateDuration(-1);
+            this.currentPlayState = null;
+            updateCurrentTime(-1);
+        }
+
+    }
+
+    @Override
+    public void handleEvent(EmbyPlayStateModel playstate, String hostname, int embyport) {
+        // check the deviceId of this handler against the deviceId of the event to see if it matches
+        if (playstate.compareDeviceId(config.deviceID)) {
+            this.currentPlayState = playstate;
+            logger.debug("the deviceId for: {} matches the deviceId of the thing so we will update stringUrl",
+                    playstate.getDeviceName());
+            Configuration config = this.thing.getChannel(CHANNEL_IMAGEURL).getConfiguration();
+            String maxWidth = null;
+            String maxHeight = null;
+            Boolean percentPlayed = null;
+
+            // String maxWidth = config.get(CHANNEL_IMAGEURL_MAXWIDTH).toString();
+            // String maxHeight = config.get(CHANNEL_IMAGEURL_MAXHEIGHT).toString();
+            // Boolean percentPlayed = (Boolean) config.get(CHANNEL_IMAGEURL_PERCENTPLAYED);
+            // if (percentPlayed == null) {
+            // percentPlayed = true;
+            // }
+
+            try {
+                maxWidth = this.thing.getChannel(CHANNEL_IMAGEURL).getConfiguration().get(CHANNEL_IMAGEURL_MAXWIDTH)
+                        .toString();
+            } catch (NullPointerException e) {
+                logger.debug("The maxWidth was not set so we keep value as null");
+            }
+
+            try {
+                maxHeight = this.thing.getChannel(CHANNEL_IMAGEURL).getConfiguration().get(CHANNEL_IMAGEURL_MAXHEIGHT)
+                        .toString();
+            } catch (NullPointerException e) {
+                logger.debug("The maxHeight was not set so we keep value as null");
+            }
+            try {
+                percentPlayed = (Boolean) this.thing.getChannel(CHANNEL_IMAGEURL).getConfiguration()
+                        .get(CHANNEL_IMAGEURL_PERCENTPLAYED);
+                if (percentPlayed == null) {
+                    percentPlayed = true;
+                }
+            } catch (NullPointerException e) {
+                logger.debug("The Percent Played setting was not set so we keep value as true");
+            }
+
+            try {
+                URI imageURI = playstate.getPrimaryImageURL(hostname, embyport,
+                        config.get(CHANNEL_IMAGEURL_TYPE).toString(), maxWidth, maxHeight, percentPlayed);
+                if (imageURI.getHost().equals("NotPlaying")) {
+                    updateState(EmbyState.END);
+                    updateState(EmbyState.STOP);
+
+                } else {
+                    if (playstate.getEmbyPlayStatePausedState()) {
+                        logger.debug("The playstate for {} is being set to pause", playstate.getDeviceName());
+                        updateState(EmbyState.PAUSE);
+
+                    } else {
+                        logger.debug("The playstate for {} is being set to play", playstate.getDeviceName());
+                        updateState(EmbyState.PLAY);
+                    }
+                    updatePrimaryImageURL(imageURI.toString());
+                    updateMuted(playstate.getEmbyMuteSate());
+                    updateShowTitle(playstate.getNowPlayingName());
+                    updateCurrentTime(playstate.getNowPlayingTime().longValue());
+                    updateDuration(playstate.getNowPlayingTotalTime().longValue());
+                    updateMediaType(playstate.getNowPlayingMediaType());
+                }
+            } catch (URISyntaxException e) {
+                logger.debug("unable to create image url for: {} due to exception: {} ", playstate.getDeviceName(),
+                        e.toString());
+            }
+        } else {
+            logger.debug("{} does not equal {} the event is for device named: {} ", playstate.getDeviceId(),
+                    config.deviceID, playstate.getDeviceName());
+        }
+    }
+}
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyNowPlayingItem.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyNowPlayingItem.java
new file mode 100644
index 0000000000000..b87f82c32527b
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyNowPlayingItem.java
@@ -0,0 +1,82 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.emby.internal.model;
+
+import java.math.BigDecimal;
+
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * embyPlayState - part of the model for the json object received from the server
+ *
+ * @author Zachary Christiansen - Initial Contribution
+ *
+ */
+public class EmbyNowPlayingItem {
+
+    @SerializedName("Name")
+    private String name;
+    @SerializedName("OriginalTitle")
+    private String originalTitle;
+    @SerializedName("Id")
+    private String id;
+    @SerializedName("RunTimeTicks")
+    private BigDecimal runTimeTicks;
+    @SerializedName("Overview")
+    private String overview;
+    @SerializedName("SeasonId")
+    private String seasonId;
+    @SerializedName("Type")
+    private String nowPlayingType;
+
+    String getName() {
+        return name;
+
+    }
+
+    String getSeasonId() {
+        return this.seasonId;
+    }
+
+    String getNowPlayingType() {
+        return nowPlayingType;
+
+    }
+
+    String getOriginalTitle() {
+        return originalTitle;
+
+    }
+
+    /**
+     * @return the media source id of the now playing item
+     */
+    String getId() {
+        return this.id;
+
+    }
+
+    /**
+     * @return the total runtime ticks of the currently playing item
+     */
+    BigDecimal getRunTimeTicks() {
+        return runTimeTicks;
+
+    }
+
+    String getOverview() {
+        return overview;
+
+    }
+
+}
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyPlayState.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyPlayState.java
new file mode 100644
index 0000000000000..8c2901d41b0f6
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyPlayState.java
@@ -0,0 +1,69 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.emby.internal.model;
+
+import java.math.BigDecimal;
+
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * embyPlayState - part of the model for the json object received from the server
+ *
+ * @author Zachary Christiansen - Initial Contribution
+ *
+ */
+public class EmbyPlayState {
+
+    @SerializedName("PositionTicks")
+    private BigDecimal positionTicks;
+    @SerializedName("CanSeek")
+    private boolean canSeek;
+    @SerializedName("IsPaused")
+    private boolean isPaused;
+    @SerializedName("IsMuted")
+    private boolean isMuted;
+    @SerializedName("VolumeLevel")
+    private Integer volumeLevel;
+    @SerializedName("MediaSourceId")
+    private String mediaSoureId;
+    @SerializedName("PlayMethod")
+    private String playMethod;
+    @SerializedName("repeatMode")
+    private String repeatMode;
+
+    /**
+     * @return the current position in the playback of the now playing item, can be compared to the total
+     *         runtimeticks
+     *         to get percentage played
+     */
+    BigDecimal getPositionTicks() {
+        return positionTicks;
+    }
+
+    boolean getPaused() {
+        return isPaused;
+    }
+
+    boolean getIsMuted() {
+        return isMuted;
+    }
+
+    /**
+     * @return the item id of the now playing item
+     */
+    String getMediaSourceID() {
+        return mediaSoureId;
+
+    }
+
+}
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyPlayStateModel.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyPlayStateModel.java
new file mode 100644
index 0000000000000..c572a70fb5e17
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyPlayStateModel.java
@@ -0,0 +1,188 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.emby.internal.model;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.net.URI;
+import java.net.URISyntaxException;
+
+import org.openhab.binding.emby.internal.protocol.EmbyDeviceEncoder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * The {@link EmbyPlayStateModelGson} is responsible to hold
+ * data that models pin information which can be sent to a Konnected Module
+ *
+ * @author Zachary Christiansen - Initial contribution
+ *
+ */
+public class EmbyPlayStateModel {
+
+    @SerializedName("PlayState")
+    private EmbyPlayState playState;
+    @SerializedName("RemoteEndPoint")
+    private String remoteEndPoint;
+    @SerializedName("Id")
+    private String id;
+    @SerializedName("UserId")
+    private String userId;
+    @SerializedName("UserName")
+    private String userName;
+    @SerializedName("Client")
+    private String client;
+    @SerializedName("DeviceName")
+    private String deviceName;
+    @SerializedName("DeviceId")
+    private String deviceId;
+    @SerializedName("SupportsRemoteControl")
+    private Boolean supportsRemoteControl;
+    @SerializedName("NowPlayingItem")
+    private EmbyNowPlayingItem nowPlayingItem;
+    private final Logger logger = LoggerFactory.getLogger(EmbyPlayStateModel.class);
+
+    public EmbyPlayState getPlayStates() {
+        return playState;
+    }
+
+    public Boolean getEmbyPlayStatePausedState() {
+        return this.playState.getPaused();
+
+    }
+
+    public Boolean getEmbyMuteSate() {
+        return this.playState.getIsMuted();
+    }
+
+    public String getNowPlayingName() {
+        return this.nowPlayingItem.getName();
+    }
+
+    public BigDecimal getNowPlayingTime() {
+        return this.playState.getPositionTicks();
+    }
+
+    public BigDecimal getNowPlayingTotalTime() {
+        return this.nowPlayingItem.getRunTimeTicks();
+    }
+
+    public String getNowPlayingMediaType() {
+        return this.getNowPlayingItem().getNowPlayingType();
+    }
+
+    public Boolean compareDeviceId(String compareId) {
+        try {
+            return getDeviceId().equals(compareId);
+        } catch (NullPointerException e) {
+            return false;
+        }
+    }
+
+    /**
+     * @return the BigInteger Value of the PlayState PositionTicks over the Total Run Time Position Ticks which is the
+     *         mathmatical representation of the percentage played
+     */
+    public BigDecimal getPercentPlayed() {
+        return (playState.getPositionTicks().divide(nowPlayingItem.getRunTimeTicks(), 2, RoundingMode.HALF_UP));
+
+    }
+
+    public EmbyNowPlayingItem getNowPlayingItem() {
+        return nowPlayingItem;
+    }
+
+    /**
+     * @return the ip address of the user playing the meida
+     */
+    public String getRemoteEndPoint() {
+        return remoteEndPoint;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    /**
+     * @return the emby id of the user playing the media, this can be used to obtain the images in conjunction with the
+     *         media id
+     */
+    public String getuserId() {
+        return userId;
+    }
+
+    public String userName() {
+        return userName;
+    }
+
+    public String getClient() {
+        return client;
+    }
+
+    public String getDeviceName() {
+        return deviceName;
+    }
+
+    public String getDeviceId() {
+        EmbyDeviceEncoder encode = new EmbyDeviceEncoder();
+        return encode.encodeDeviceID(deviceId);
+    }
+
+    public Boolean getSupportsRemoteControl() {
+        return supportsRemoteControl;
+    }
+
+    public URI getPrimaryImageURL(String embyHost, int embyPort, String embyType, String maxWidth, String maxHeight,
+            Boolean percentPlayed) throws URISyntaxException {
+        String imagePath = "";
+        logger.debug(
+                "Received an image URL request for: {} , embyPort: {}, embyType: {}, maxWidth: {}, maxHeight: {}, percentPlayed: {}",
+                embyHost, embyPort, embyType, maxWidth, maxHeight, percentPlayed);
+        if (this.nowPlayingItem == null) {
+            // If there is no nowPlayingItem this means the device has stopped so we will return
+            // a URI that will let us check for that, if any of this returns null
+            URI imageURI = new URI("http", null, "NotPlaying", 8096, null, null, null);
+            return imageURI;
+        } else {
+            if (this.nowPlayingItem.getNowPlayingType().equalsIgnoreCase("Episode")) {
+                // if its a TV Series use that instead of ID for image
+                imagePath = "/emby/items/" + this.nowPlayingItem.getSeasonId() + "/Images/" + embyType;
+            } else {
+                imagePath = "/emby/items/" + this.nowPlayingItem.getId() + "/Images/" + embyType;
+            }
+
+            String query = "";
+
+            if (percentPlayed) {
+                BigDecimal percentPlayedRounded = getPercentPlayed();
+                double percent = percentPlayedRounded.doubleValue();
+                percent = percent * 100;
+                query = query + new String("PercentPlayed=" + Double.toString(percent));
+            }
+
+            if (!(maxWidth == null)) {
+                query = "MaxWidth=" + maxWidth + "&" + query;
+            }
+
+            if (!(maxHeight == null)) {
+                query = "MaxHeight=" + maxHeight + "&" + query;
+            }
+
+            // http://192.168.20.152:8096/emby/Items/%7BItemid%7D/Images/Primary?PercentPlayed=47
+            URI imageURI = new URI("http", null, embyHost, embyPort, imagePath, query, null);
+            return imageURI;
+        }
+    }
+}
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyPlayingPostJsonModel.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyPlayingPostJsonModel.java
new file mode 100644
index 0000000000000..68d2b9c157a08
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyPlayingPostJsonModel.java
@@ -0,0 +1,93 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.emby.internal.model;
+
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * embyPlayState - part of the model for the json object received from the server
+ *
+ * @author Zachary Christiansen - Initial Contribution
+ *
+ */
+public class EmbyPlayingPostJsonModel {
+
+    @SerializedName("ItemsIds")
+    private String itemsIds;
+    @SerializedName("PlayCommand")
+    private String playCommand;
+
+    @SerializedName("StartPositionTicks")
+    private String startPositionTicks;
+
+    @SerializedName("MediaSourceId")
+    private String mediaSourceId;
+
+    @SerializedName("AudioStreamIndex")
+    private String audioStreamIndex;
+
+    @SerializedName("SubtitleStreamIndex")
+    private String subtitleStreamIndex;
+
+    @SerializedName("StartIndex")
+    private String startIndex;
+
+    public String getItemsIds() {
+        return this.itemsIds;
+    }
+
+    public void setItemsIds(String settingItemsIds) {
+        this.itemsIds = settingItemsIds;
+    }
+
+    public String getPlayCommand() {
+        return this.playCommand;
+    }
+
+    public void setPlayCommand(String settingPlayCommand) {
+        this.playCommand = settingPlayCommand;
+    }
+
+    public String getStartPositionTicks() {
+        return this.startPositionTicks;
+    }
+
+    public void setStartPositionTicks(String settingStartPositionTicks) {
+        this.startPositionTicks = settingStartPositionTicks;
+    }
+
+    public String getMediaSourceIds() {
+        return this.mediaSourceId;
+    }
+
+    public void setMediaSourceId0(String settingMediaSourceId) {
+        this.mediaSourceId = settingMediaSourceId;
+    }
+
+    public String getSubtitleStreamIndex() {
+        return this.subtitleStreamIndex;
+    }
+
+    public void setSubtitleStreamIndex(String settingSubtitleStreamIndex) {
+        this.subtitleStreamIndex = settingSubtitleStreamIndex;
+    }
+
+    public String getStartIndex() {
+        return this.startIndex;
+    }
+
+    public void setStartIndex(String settingStartIndex) {
+        this.startIndex = settingStartIndex;
+    }
+
+}
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyClientSocket.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyClientSocket.java
new file mode 100644
index 0000000000000..d76c02e0ba77d
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyClientSocket.java
@@ -0,0 +1,245 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.emby.internal.protocol;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.net.URI;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+import org.eclipse.jetty.websocket.api.Session;
+import org.eclipse.jetty.websocket.api.annotations.OnWebSocketClose;
+import org.eclipse.jetty.websocket.api.annotations.OnWebSocketConnect;
+import org.eclipse.jetty.websocket.api.annotations.OnWebSocketError;
+import org.eclipse.jetty.websocket.api.annotations.OnWebSocketMessage;
+import org.eclipse.jetty.websocket.api.annotations.WebSocket;
+import org.eclipse.jetty.websocket.client.ClientUpgradeRequest;
+import org.eclipse.jetty.websocket.client.WebSocketClient;
+import org.openhab.binding.emby.internal.model.EmbyPlayStateModel;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import com.google.gson.reflect.TypeToken;
+
+/**
+ * EmbyClientSocket implements the low level communication to Emby through
+ * websocket. Usually this communication is done through port 9090
+ *
+ * @author Zachary Christiansen - Initial contribution
+ *
+ */
+public class EmbyClientSocket {
+
+    private final Logger logger = LoggerFactory.getLogger(EmbyClientSocket.class);
+
+    private final ScheduledExecutorService scheduler;
+    private static final int REQUEST_TIMEOUT_MS = 60000;
+
+    private CountDownLatch commandLatch = null;
+    private JsonObject commandResponse = null;
+
+    private boolean connected = false;
+
+    private final JsonParser parser = new JsonParser();
+    private final Gson mapper = new Gson();
+    private URI uri;
+    private Session session;
+    private WebSocketClient client;
+    private int bufferSize;
+
+    private final EmbyClientSocketEventListener eventHandler;
+
+    public EmbyClientSocket(EmbyClientSocketEventListener eventHandler, URI uri, ScheduledExecutorService scheduler,
+            int buffersize) {
+        this.eventHandler = eventHandler;
+        this.uri = uri;
+        client = new WebSocketClient();
+        this.scheduler = scheduler;
+        this.bufferSize = buffersize;
+    }
+
+    /**
+     * Attempts to create a connection to the Emby host and begin listening for
+     * updates over the async http web socket
+     *
+     * @throws Exception
+     */
+    public synchronized void open() throws Exception {
+        if (isConnected()) {
+            logger.warn("connect: connection is already open");
+        }
+        if (!client.isStarted()) {
+            client.start();
+            client.setMaxTextMessageBufferSize(bufferSize);
+        }
+        EmbyWebSocketListener socket = new EmbyWebSocketListener();
+        ClientUpgradeRequest request = new ClientUpgradeRequest();
+
+        client.connect(socket, uri, request);
+    }
+
+    /***
+     * Close this connection to the Emby instance
+     */
+    public void close() {
+        // if there is an old web socket then clean up and destroy
+        if (session != null) {
+            try {
+                session.close();
+            } catch (Exception e) {
+                logger.debug("Exception during closing the websocket: {}", e.getMessage(), e);
+            }
+            session = null;
+        }
+        try {
+            client.stop();
+        } catch (Exception e) {
+            logger.debug("Exception during closing the websocket: {}", e.getMessage(), e);
+        }
+    }
+
+    public boolean isConnected() {
+        if (session == null || !session.isOpen()) {
+            return false;
+        }
+
+        return connected;
+    }
+
+    @WebSocket
+    public class EmbyWebSocketListener {
+        @OnWebSocketConnect
+        public void onConnect(Session wssession) {
+            logger.debug("Connected to server");
+            session = wssession;
+            connected = true;
+            if (eventHandler != null) {
+                scheduler.submit(() -> {
+                    try {
+                        eventHandler.onConnectionOpened();
+                    } catch (Exception e) {
+                        logger.debug("Error handling onConnectionOpened(): {}", e.getMessage(), e);
+                    }
+                });
+            }
+        }
+
+        @OnWebSocketMessage
+        public void onMessage(String message) {
+            logger.debug("Message received from server: {}", message);
+            final JsonObject json = parser.parse(message).getAsJsonObject();
+            if (json.has("Data")) {
+                JsonArray messageId = json.get("Data").getAsJsonArray();
+                Gson gson = new Gson();
+                Type type = new TypeToken<List<EmbyPlayStateModel>>() {
+                }.getType();
+                List<EmbyPlayStateModel> response = gson.fromJson(messageId, type);
+
+                response.forEach(playstate -> {
+
+                    // need to add internal validation method check but right now will pass all states to handler
+                    eventHandler.handleEvent(playstate);
+
+                });
+            }
+        }
+
+        @OnWebSocketClose
+        public void onClose(int statusCode, String reason) {
+            logger.debug("Closing a WebSocket due to {} with status code: {}", reason, Integer.toString(statusCode));
+            session = null;
+            connected = false;
+            if (eventHandler != null) {
+                scheduler.submit(() -> {
+                    try {
+                        eventHandler.onConnectionClosed();
+                    } catch (Exception e) {
+                        logger.debug("Error handling onConnectionClosed(): {}", e.getMessage(), e);
+                    }
+                });
+            }
+        }
+
+        @OnWebSocketError
+        public void onError(Throwable error) {
+            onClose(0, error.getMessage());
+        }
+
+    }
+
+    private void sendMessage(String str) throws IOException {
+        if (isConnected()) {
+            logger.debug("send message: {}", str);
+            session.getRemote().sendString(str);
+        } else {
+            throw new IOException("socket not initialized");
+        }
+    }
+
+    public JsonElement callMethod(String methodName) {
+        return callMethod(methodName, null);
+    }
+
+    public JsonElement callMethodString(String methodName, String dataParams) {
+        JsonObject payloadObject = new JsonObject();
+        payloadObject.addProperty("MessageType", methodName);
+        payloadObject.addProperty("Data", dataParams);
+        return callMethod(payloadObject);
+    }
+
+    public JsonElement callMethod(String methodName, JsonObject params) {
+        JsonObject payloadObject = new JsonObject();
+        // payloadObject.addProperty("jsonrpc", "2.0");
+        // payloadObject.addProperty("id", nextMessageId);
+        payloadObject.addProperty("MessageType", methodName);
+        if (params != null) {
+            payloadObject.add("Data", params);
+        }
+        return callMethod(payloadObject);
+    }
+
+    public synchronized JsonElement callMethod(JsonObject payloadObject) {
+        try {
+            String message = mapper.toJson(payloadObject);
+            commandLatch = new CountDownLatch(1);
+            commandResponse = null;
+            sendMessage(message);
+            if (commandLatch.await(REQUEST_TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
+                logger.debug("callMethod returns {}", commandResponse);
+                if (commandResponse.has("result")) {
+                    return commandResponse.get("result");
+                } else {
+                    JsonElement error = commandResponse.get("error");
+                    logger.debug("Error received from server: {}", error);
+                    return null;
+                }
+            } else {
+                logger.debug("Timeout during callMethod({}, {})", payloadObject.get("MessageType").toString(),
+                        payloadObject.get("Data").toString());
+                return null;
+            }
+        } catch (Exception e) {
+            logger.debug("Error during callMethod({}): {}", payloadObject.get("MessageType").toString(), e.getMessage(),
+                    e);
+            return null;
+        }
+    }
+}
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyClientSocketEventListener.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyClientSocketEventListener.java
new file mode 100644
index 0000000000000..aa3d05e1a206a
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyClientSocketEventListener.java
@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.emby.internal.protocol;
+
+import org.openhab.binding.emby.internal.model.EmbyPlayStateModel;
+
+/**
+ * This interface has to be implemented for classes which need to be able to receive events from EmbyClientSocket
+ *
+ * @author Zachary Christiansen - Initial contribution
+ *
+ */
+public interface EmbyClientSocketEventListener {
+
+    void handleEvent(EmbyPlayStateModel playstate);
+
+    void onConnectionClosed();
+
+    void onConnectionOpened();
+
+}
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyConnection.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyConnection.java
new file mode 100644
index 0000000000000..ecdd5a8b73bc1
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyConnection.java
@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.emby.internal.protocol;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.concurrent.ScheduledExecutorService;
+
+import org.openhab.binding.emby.internal.EmbyBridgeListener;
+import org.openhab.binding.emby.internal.model.EmbyPlayStateModel;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * EmbyConnection provides an API for accessing a Emby device.
+ *
+ * @author Zachary Christiansen - Initial contribution
+ */
+
+public class EmbyConnection implements EmbyClientSocketEventListener {
+
+    private final Logger logger = LoggerFactory.getLogger(EmbyConnection.class);
+
+    private int refreshRate;
+    private String hostname;
+    private int embyport;
+    private URI wsUri;
+    private EmbyClientSocket socket;
+
+    private final EmbyBridgeListener listener;
+
+    public EmbyConnection(EmbyBridgeListener listener) {
+        this.listener = listener;
+
+    }
+
+    @Override
+    public synchronized void onConnectionClosed() {
+        listener.updateConnectionState(false);
+    }
+
+    @Override
+    public synchronized void onConnectionOpened() {
+        listener.updateConnectionState(true);
+
+        socket.callMethodString("SessionsStart", "0," + Integer.toString(this.refreshRate));
+    }
+
+    public synchronized void connect(String hostname, int port, String apiKey, ScheduledExecutorService scheduler,
+            int refreshRate, int bufferSize) {
+        this.hostname = hostname;
+        this.embyport = port;
+        this.refreshRate = refreshRate;
+        try {
+            close();
+
+            wsUri = new URI("ws", null, hostname, port, null, "api_key=" + apiKey, null);
+            socket = new EmbyClientSocket(this, wsUri, scheduler, bufferSize);
+            checkConnection();
+        } catch (URISyntaxException e) {
+            logger.error("exception during constructing URI host={}, port={}", hostname, port, e);
+        }
+    }
+
+    public synchronized void close() {
+        if (socket != null && socket.isConnected()) {
+            socket.close();
+        }
+    }
+
+    @Override
+    public void handleEvent(EmbyPlayStateModel playstate) {
+        logger.debug("Received event from EMBY server passing it to the bridge handler with hostname {} and port {}",
+                hostname, embyport);
+        this.listener.handleEvent(playstate, this.hostname, this.embyport);
+    }
+
+    public boolean checkConnection() {
+        if (!socket.isConnected()) {
+            logger.debug("checkConnection: try to connect to emby {}", wsUri);
+            try {
+                socket.open();
+                return socket.isConnected();
+            } catch (Exception e) {
+                logger.error("exception during connect to {}", wsUri, e);
+                socket.close();
+                return false;
+            }
+        } else {
+            return true;
+        }
+    }
+
+    public String getConnectionName() {
+        return wsUri.toString();
+    }
+
+}
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyDeviceEncoder.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyDeviceEncoder.java
new file mode 100644
index 0000000000000..c00aa37d763f7
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyDeviceEncoder.java
@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.emby.internal.protocol;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * EmbyClientSocket implements the low level communication to Emby through
+ * websocket. Usually this communication is done through port 9090
+ *
+ * @author Zachary Christiansen - Initial contribution
+ *
+ */
+public class EmbyDeviceEncoder {
+
+    private final Logger logger = LoggerFactory.getLogger(EmbyDeviceEncoder.class);
+
+    public String encodeDeviceID(String deviceID) {
+        return deviceID.replaceAll("[^A-Za-z0-9]", "UYHJKU");
+    }
+}
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyHTTPUtils.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyHTTPUtils.java
new file mode 100644
index 0000000000000..daa6c6a23f501
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyHTTPUtils.java
@@ -0,0 +1,94 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.emby.internal.protocol;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.Properties;
+import java.util.concurrent.TimeUnit;
+
+import org.eclipse.smarthome.io.net.http.HttpUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * HTTP Get and Put reqeust class.
+ *
+ * @author Zachary Christiansen - Initial contribution
+ */
+public class EmbyHTTPUtils {
+    private final Logger logger = LoggerFactory.getLogger(EmbyHTTPUtils.class);
+    private int requestTimeout;
+    private String apiKey;
+    private String hostIpPort;
+    private String logTest = "";
+
+    public EmbyHTTPUtils(int requestTimeout, String apiKey, String hostIpPort) {
+        this.requestTimeout = (int) TimeUnit.SECONDS.toMillis(requestTimeout);
+        this.apiKey = apiKey;
+        this.hostIpPort = hostIpPort;
+    }
+
+    public void setRequestTimeout(int requestTimeout) {
+        this.requestTimeout = (int) TimeUnit.SECONDS.toMillis(requestTimeout);
+    }
+
+    /**
+     * Sends a {@link doPost} request with a timeout of 30 seconds
+     *
+     * @param urlAddress the address to send the request
+     * @param payload the json payload to include with the request
+     */
+    private String doPost(String urlAddress, String payload) throws IOException {
+        urlAddress = "http://" + hostIpPort + urlAddress;
+        logger.debug("The String url we want to post is : {}", urlAddress);
+        logger.debug("The payload we want to post is: {}", payload);
+        ByteArrayInputStream input = new ByteArrayInputStream(payload.getBytes(StandardCharsets.UTF_8));
+        logTest = HttpUtil.executeUrl("POST", urlAddress, getHttpHeaders(), input, "application/json", requestTimeout);
+        logger.debug("{}", logTest);
+        return logTest;
+    }
+
+    protected Properties getHttpHeaders() {
+        Properties httpHeaders = new Properties();
+        httpHeaders.put("Content-Type", "application/json");
+        httpHeaders.put("X-Emby-Token", this.apiKey);
+        return httpHeaders;
+    }
+
+    /**
+     * Sends a {@link doPost} request with a timeout of 30 seconds
+     *
+     * @param urlAddress the address to send the request
+     * @param payload the json payload you want to send as part of the request
+     * @param retry the number of retries before throwing the IOexpcetion back to the handler
+     */
+    public synchronized String doPost(String urlAddress, String payload, int retryCount) throws EmbyHttpRetryExceeded {
+        String response = null;
+        int x = 0;
+        Boolean loop = true;
+        while (loop) {
+            try {
+                response = doPost(urlAddress, payload);
+                loop = false;
+            } catch (IOException e) {
+                x++;
+                if (x > retryCount) {
+                    throw new EmbyHttpRetryExceeded("The number of retry attempts was exceeded", e.getCause());
+                }
+            }
+        }
+        return response;
+    }
+}
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyHttpRetryExceeded.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyHttpRetryExceeded.java
new file mode 100644
index 0000000000000..f47dc15ba7a64
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyHttpRetryExceeded.java
@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.emby.internal.protocol;
+
+/**
+ * Custom exception class to be thrown when number of retries is exceeded.
+ *
+ * @author Zachary Christiansen - Initial contribution
+ */
+@SuppressWarnings("serial")
+public class EmbyHttpRetryExceeded extends Exception {
+    public EmbyHttpRetryExceeded(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
diff --git a/bundles/org.openhab.binding.emby/src/main/resources/ESH-INF/binding/binding.xml b/bundles/org.openhab.binding.emby/src/main/resources/ESH-INF/binding/binding.xml
new file mode 100644
index 0000000000000..a5213dfa9b81a
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/src/main/resources/ESH-INF/binding/binding.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<binding:binding id="emby" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xmlns:binding="https://openhab.org/schemas/binding/v1.0.0"
+	xsi:schemaLocation="https://openhab.org/schemas/binding/v1.0.0 https://openhab.org/schemas/binding-1.0.0.xsd">
+
+	<name>Emby Binding</name>
+	<description>This is the binding for Emby.</description>
+	<author>Zachary Christiansen</author>
+
+</binding:binding>
diff --git a/bundles/org.openhab.binding.emby/src/main/resources/ESH-INF/thing/thing-types.xml b/bundles/org.openhab.binding.emby/src/main/resources/ESH-INF/thing/thing-types.xml
new file mode 100644
index 0000000000000..3fa05130001a9
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/src/main/resources/ESH-INF/thing/thing-types.xml
@@ -0,0 +1,195 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<thing:thing-descriptions bindingId="emby"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xmlns:thing="https://openhab.org/schemas/thing-description/v1.0.0"
+	xsi:schemaLocation="https://openhab.org/schemas/thing-description/v1.0.0 https://openhab.org/schemas/thing-description-1.0.0.xsd">
+	<!-- Sample Thing Type -->
+	<bridge-type id="controller">
+		<label>EMBY Server</label>
+		<description>This is the Bridge to an instance of an EMBY server you want to connect to.</description>
+		<config-description>
+			<parameter name="api" type="text" required="true">
+				<label>API Key</label>
+				<description>This is the API key generated from EMBY used for Authorization.</description>
+			</parameter>
+			<parameter name="buffer_size" type="integer">
+				<label>Web Socket Buffer Size</label>
+				<description>Here you can define a custom size for the websocket buffer size. Default is 100000</description>
+				<advanced>true</advanced>
+			</parameter>
+			<parameter name="ipAddress" type="text" required="true">
+				<label>ipAddress</label>
+				<description>This is the ip address of the EMBY Server.</description>
+			</parameter>
+			<parameter name="port" type="text" required="true">
+				<label>Port</label>
+				<description>This is the port of the EMBY server.</description>
+			</parameter>
+			<parameter name="refreshInterval" type="integer" required="true">
+				<label>Refresh Parameter</label>
+				<description>This is the refresh interval in milliseconds that will be sent to the websocket.</description>
+			</parameter>
+		</config-description>
+	</bridge-type>
+	<thing-type id="device" extensible="generalCommand">
+		<supported-bridge-type-refs>
+			<bridge-type-ref id="controller" />
+		</supported-bridge-type-refs>
+		<label>EMBY Binding Device</label>
+		<description>This  is a player device which connects to an EMBY server to play files that you want to montior.</description>
+		<channels>
+			<channel id="control" typeId="control" />
+			<channel id="stop" typeId="stop" />
+			<channel id="title" typeId="title" />
+			<channel id="mute" typeId="mute" />
+			<channel id="showtitle" typeId="showtitle" />
+			<channel id="imageurl" typeId="imageurl" />
+			<channel id="currenttime" typeId="currenttime" />
+			<channel id="duration" typeId="duration" />
+			<channel id="mediatype" typeId="mediatype" />
+			<channel id="sendplay" typeId="sendplay" />
+		</channels>
+		<config-description>
+			<parameter name="deviceID" type="text" required="true">
+				<label>DeviceID</label>
+				<description>This is the deviceId you want to connect to to monitor.</description>
+			</parameter>
+		</config-description>
+	</thing-type>
+	<channel-type id="sendplay">
+		<item-type>String</item-type>
+		<label>Send Play</label>
+		<description>String to send a comma-delimited list of item id's that will be played by the client. The string should be in JSON format with all desired parameters from the EMBY API. https://github.com/MediaBrowser/Emby/wiki/Remote-control</description>
+		<state pattern="%s" />
+	</channel-type>
+	<channel-type id="title">
+		<item-type>String</item-type>
+		<label>Title</label>
+		<description>Title of the current song</description>
+		<state readOnly="true" pattern="%s" />
+	</channel-type>
+	<channel-type id="showtitle">
+		<item-type>String</item-type>
+		<label>Show Title</label>
+		<description>Title of the current show</description>
+		<state readOnly="true" pattern="%s" />
+	</channel-type>
+	<channel-type id="control">
+		<item-type>Player</item-type>
+		<label>Control</label>
+		<description>Control the Emby Player, e.g. start/stop/next/previous/ffward/rewind</description>
+		<category>Player</category>
+	</channel-type>
+	<channel-type id="stop">
+		<item-type>Switch</item-type>
+		<label>Stop</label>
+		<description>Stops the player. ON if the player is stopped.</description>
+	</channel-type>
+	<channel-type id="mute">
+		<item-type>Switch</item-type>
+		<label>Mute</label>
+		<description>Mute/unmute your device</description>
+	</channel-type>
+	<channel-type id="currenttime">
+		<item-type>Number:Time</item-type>
+		<label>Current Time</label>
+		<description>Current time of currently playing media</description>
+		<state readOnly="true" pattern="%d %unit%" />
+	</channel-type>
+	<channel-type id="duration">
+		<item-type>Number:Time</item-type>
+		<label>Duration</label>
+		<description>Length of currently playing media</description>
+		<state readOnly="true" pattern="%d %unit%" />
+	</channel-type>
+	<channel-type id="mediatype">
+		<item-type>String</item-type>
+		<label>Media Type</label>
+		<description>Media type of the current file</description>
+		<state readOnly="true" pattern="%s" />
+	</channel-type>
+	<channel-type id="generalCommand">
+		<item-type>Switch</item-type>
+		<label>General Command</label>
+		<description>Send a general command</description>
+		<config-description>
+			<parameter name="generalCommand_CommandName" type="text">
+				<options>
+					<option value="MoveUp">Move Up</option>
+					<option value="MoveDown">Move Down</option>
+					<option value="MoveLeft">Move Left</option>
+					<option value="MoveRight">Move Right</option>
+					<option value="PageUp">Page Up</option>
+					<option value="PageDown">Page Down</option>
+					<option value="PreviousLetter">Previous Letter</option>
+					<option value="NextLetter">Next Letter</option>
+					<option value="ToggleOsdMenu">Toggle Osd Menu</option>
+					<option value="ToggleContextMenu">Toggle Context Menu</option>
+					<option value="ToggleMute">Toggle Mute</option>
+					<option value="Select">Select</option>
+					<option value="Back">Back</option>
+					<option value="TakeScreenshot">Take Screenshot</option>
+					<option value="GoHome">Go Home</option>
+					<option value="GoToSettings">Go To Settings</option>
+					<option value="VolumeUp">Volume Up</option>
+					<option value="VolumeDown">Volume Down</option>
+					<option value="ToggleFullscreen">Toggle Full Screen</option>
+					<option value="GoToSearch">Go To Search</option>
+				</options>
+			</parameter>
+		</config-description>
+	</channel-type>
+	<channel-type id="generalCommand_withArguments">
+		<item-type>String</item-type>
+		<label>General Command With Arguments</label>
+		<description>Send a general command that accepts arguments.  The argument should be sent as a string in json format. For example, SetVolume - {Volume:50}</description>
+		<config-description>
+			<parameter name="generalCommand_CommandName" type="text">
+				<options>
+					<option value="SetVolume">Set Volume</option>
+					<option value="SetAudioStreamIndex">Set Audio Stream Index</option>
+					<option value="SetSubtitleStreamIndex">Set Subtitle Stream Index</option>
+					<option value="DisplayContent">Display Content</option>
+					<option value="PlayTrailers">Play Trailers</option>
+				</options>
+			</parameter>
+		</config-description>
+	</channel-type>
+	<channel-type id="imageurl">
+		<item-type>String</item-type>
+		<label>image url</label>
+		<description>The url of the playing media</description>
+		<state readOnly="true" pattern="%s" />
+		<config-description>
+			<parameter name="imageurl_type" type="text">
+				<default>Primary</default>
+				<options>
+					<option value="Primary">Primary</option>
+					<option value="Art">Art</option>
+					<option value="Backdrop">Backdrop</option>
+					<option value="Banner">Banner</option>
+					<option value="Logo">Logo</option>
+					<option value="Thumb">Thumb</option>
+					<option value="Disc">Disc</option>
+					<option value="Box">Box</option>
+					<option value="Screenshot">Screenshot</option>
+					<option value="Menu">Menu</option>
+					<option value="Chapter">Chapter</option>
+				</options>
+			</parameter>
+			<parameter name="imageurl_maxHeight" type="text">
+				<label>Image Max Height</label>
+				<description>The maximum height of the image that will be retrieved.</description>
+			</parameter>
+			<parameter name="imageurl_maxWidth" type="text">
+				<label>Image Max Width</label>
+				<description>The maximum width of the image that will be retrieved.</description>
+			</parameter>
+			<parameter name="imageurl_PercentPlayed" type="boolean">
+				<label>Percent Played</label>
+			<description>When set to true (default) the image url will have the percent played indicator on the image.  Set to false to not display the percent played indicator</description>
+			</parameter>
+		</config-description>
+	</channel-type>
+</thing:thing-descriptions>
+
diff --git a/bundles/pom.xml b/bundles/pom.xml
index 132ec52fca9f6..456221e9325ec 100644
--- a/bundles/pom.xml
+++ b/bundles/pom.xml
@@ -1,6 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 
   <modelVersion>4.0.0</modelVersion>
 
@@ -83,6 +82,7 @@
     <module>org.openhab.binding.dwdunwetter</module>
     <module>org.openhab.binding.ecobee</module>
     <module>org.openhab.binding.elerotransmitterstick</module>
+    <module>org.openhab.binding.emby</module>
     <module>org.openhab.binding.enocean</module>
     <module>org.openhab.binding.enturno</module>
     <module>org.openhab.binding.etherrain</module>

From d6408a2af00956f6f13e4f09767d6db7d2f4f3e6 Mon Sep 17 00:00:00 2001
From: Zachary Christiansen <volfan6415@gmail.com>
Date: Fri, 8 May 2020 12:13:41 -0500
Subject: [PATCH 2/3] * More updates to code. * Code cleanup after running code
 analysis * optimizations toimprove null handling

Signed-off-by: Zachary Christiansen <volfan6415@gmail.com>
---
 .../internal/EmbyBridgeConfiguration.java     |  19 +-
 .../emby/internal/EmbyBridgeListener.java     |   2 +
 .../internal/EmbyDeviceConfiguration.java     |  12 +
 .../emby/internal/EmbyEventListener.java      |   2 +
 .../emby/internal/EmbyHandlerFactory.java     |  10 +-
 ...e.java => EmbyBridgeDiscoveryService.java} |  14 +-
 .../discovery/EmbyClientDiscoveryService.java |  12 +-
 .../internal/handler/EmbyBridgeHandler.java   |  18 +-
 .../internal/handler/EmbyDeviceHandler.java   | 221 ++++++++----------
 .../internal/protocol/EmbyClientSocket.java   |  32 +--
 .../EmbyClientSocketEventListener.java        |   2 +
 .../internal/protocol/EmbyConnection.java     |  18 +-
 .../internal/protocol/EmbyDeviceEncoder.java  |   6 +-
 .../emby/internal/protocol/EmbyHTTPUtils.java |   6 +-
 .../protocol/EmbyHttpRetryExceeded.java       |   3 +
 15 files changed, 179 insertions(+), 198 deletions(-)
 rename bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/discovery/{EmbyDiscoveryService.java => EmbyBridgeDiscoveryService.java} (94%)

diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyBridgeConfiguration.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyBridgeConfiguration.java
index ffebf797bd725..127d6a8bab939 100644
--- a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyBridgeConfiguration.java
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyBridgeConfiguration.java
@@ -17,10 +17,10 @@
  *
  * @author Zachary Christiansen - Initial contribution
  */
+
 public class EmbyBridgeConfiguration {
 
     public String api;
-
     private String ipAddress;
     private Integer port;
     private Integer httpPort;
@@ -52,23 +52,6 @@ public void setHttpPort(Integer httpPort) {
         this.httpPort = httpPort;
     }
 
-    /*
-     * public String getHttpUser() {
-     * return httpUser;
-     * }
-     *
-     * public void setHttpUser(String httpUser) {
-     * this.httpUser = httpUser;
-     * }
-     *
-     * public String getHttpPassword() {
-     * return httpPassword;
-     * }
-     *
-     * public void setHttpPassword(String httpPassword) {
-     * this.httpPassword = httpPassword;
-     * }
-     */
     public Integer getRefreshInterval() {
         return refreshInterval;
     }
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyBridgeListener.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyBridgeListener.java
index b3542b2389ad9..0130aa4c4064a 100644
--- a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyBridgeListener.java
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyBridgeListener.java
@@ -14,6 +14,7 @@
 
 import java.util.EventListener;
 
+import org.eclipse.jdt.annotation.NonNullByDefault;
 import org.openhab.binding.emby.internal.model.EmbyPlayStateModel;
 import org.openhab.binding.emby.internal.protocol.EmbyConnection;
 
@@ -23,6 +24,7 @@
  *
  * @author Zachary Christiansen - Initial Contribution
  */
+@NonNullByDefault
 public interface EmbyBridgeListener extends EventListener {
 
     void updateConnectionState(boolean connected);
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyDeviceConfiguration.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyDeviceConfiguration.java
index 2948001ea93f8..8bac785778dfe 100644
--- a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyDeviceConfiguration.java
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyDeviceConfiguration.java
@@ -20,5 +20,17 @@
 public class EmbyDeviceConfiguration {
 
     public String deviceID;
+    public String imageMaxWidth;
+    public String imageMaxHeight;
+    public Boolean imagePercentPlayed;
+    public String imageImageType;
+
+    public EmbyDeviceConfiguration(String setDeviceID) {
+        deviceID = setDeviceID;
+        imageMaxWidth = null;
+        imageMaxHeight = null;
+        imagePercentPlayed = null;
+        imageImageType = null;
+    }
 
 }
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyEventListener.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyEventListener.java
index 698dd9a37bed5..0810a5c9475ce 100644
--- a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyEventListener.java
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyEventListener.java
@@ -14,6 +14,7 @@
 
 import java.util.EventListener;
 
+import org.eclipse.jdt.annotation.NonNullByDefault;
 import org.openhab.binding.emby.internal.model.EmbyPlayStateModel;
 import org.openhab.binding.emby.internal.protocol.EmbyConnection;
 
@@ -23,6 +24,7 @@
  *
  * @author Zachary Christiansen - Initial Contribution
  */
+@NonNullByDefault
 public interface EmbyEventListener extends EventListener {
     public enum EmbyState {
         PLAY,
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyHandlerFactory.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyHandlerFactory.java
index 42cba5746612c..56671d0738b0f 100644
--- a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyHandlerFactory.java
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/EmbyHandlerFactory.java
@@ -23,6 +23,7 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import org.eclipse.jdt.annotation.NonNullByDefault;
 import org.eclipse.jdt.annotation.Nullable;
 import org.eclipse.smarthome.config.discovery.DiscoveryService;
 import org.eclipse.smarthome.core.net.HttpServiceUtil;
@@ -50,16 +51,17 @@
  *
  * @author Zachary Christiansen - Initial contribution
  */
+@NonNullByDefault
 @Component(configurationPid = "binding.emby", service = ThingHandlerFactory.class)
 public class EmbyHandlerFactory extends BaseThingHandlerFactory {
 
     private Logger logger = LoggerFactory.getLogger(EmbyHandlerFactory.class);
 
-    private NetworkAddressService networkAddressService;
+    private @NonNullByDefault({}) NetworkAddressService networkAddressService;
 
     private static final Set<ThingTypeUID> SUPPORTED_THING_TYPES_UIDS = Collections
             .unmodifiableSet(Stream.of(THING_TYPE_EMBY_CONTROLLER, THING_TYPE_EMBY_DEVICE).collect(Collectors.toSet()));
-    private String callbackUrl = null;
+    private @Nullable String callbackUrl = null;
     private final Map<ThingUID, @Nullable ServiceRegistration<?>> discoveryServiceRegs = new HashMap<>();
 
     @Override
@@ -81,7 +83,7 @@ public boolean supportsThingType(ThingTypeUID thingTypeUID) {
         return null;
     }
 
-    private String createCallbackUrl() {
+    private @Nullable String createCallbackUrl() {
         if (callbackUrl != null) {
             return callbackUrl;
         } else {
@@ -94,7 +96,7 @@ private String createCallbackUrl() {
         }
     }
 
-    private String createCallbackPort() {
+    private @Nullable String createCallbackPort() {
         // we do not use SSL as it can cause certificate validation issues.
         final int port = HttpServiceUtil.getHttpServicePort(bundleContext);
         if (port == -1) {
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/discovery/EmbyDiscoveryService.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/discovery/EmbyBridgeDiscoveryService.java
similarity index 94%
rename from bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/discovery/EmbyDiscoveryService.java
rename to bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/discovery/EmbyBridgeDiscoveryService.java
index 9e95d4f019cdd..4c501db04b42b 100644
--- a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/discovery/EmbyDiscoveryService.java
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/discovery/EmbyBridgeDiscoveryService.java
@@ -48,22 +48,22 @@
 import com.google.gson.JsonObject;
 
 /**
- * The {@EmbyDiscoveryService} handles the bridge discovery which find emby servers on the network
+ * The {@EmbyBridgeDiscoveryService} handles the bridge discovery which find emby servers on the network
  *
  * @author Zachary Christiansen - Initial contribution
  */
 @NonNullByDefault
-@Component(service = DiscoveryService.class, immediate = true, configurationPid = "discovery.emby")
-public class EmbyDiscoveryService extends AbstractDiscoveryService {
+@Component(service = DiscoveryService.class, immediate = true, configurationPid = "discovery.embybridge")
+public class EmbyBridgeDiscoveryService extends AbstractDiscoveryService {
 
     private static final String REQUEST_MSG = "who is EmbyServer?";
     private static final int REQUEST_PORT = 7359;
 
-    private final Logger logger = LoggerFactory.getLogger(EmbyDiscoveryService.class);
+    private final Logger logger = LoggerFactory.getLogger(EmbyBridgeDiscoveryService.class);
     private static final Set<ThingTypeUID> SUPPORTED_THING_TYPES_UIDS = Collections
             .singleton(THING_TYPE_EMBY_CONTROLLER);
 
-    public EmbyDiscoveryService() {
+    public EmbyBridgeDiscoveryService() {
         super(SUPPORTED_THING_TYPES_UIDS, 30, false);
     }
 
@@ -172,7 +172,7 @@ public void startScan() {
         }
     }
 
-    public void addEMBYServer(String hostAddress, int embyPort, String DeviceID, String Name) {
+    public void addEMBYServer(String hostAddress, int embyPort, @Nullable String DeviceID, String Name) {
         logger.debug("creating discovery result with address: {}:{}, for server {}", hostAddress,
                 Integer.toString(embyPort), Name);
         ThingUID thingUID = getThingUID(DeviceID);
@@ -193,7 +193,7 @@ public void addEMBYServer(String hostAddress, int embyPort, String DeviceID, Str
         }
     }
 
-    private @Nullable ThingUID getThingUID(String DeviceID) {
+    private @Nullable ThingUID getThingUID(@Nullable String DeviceID) {
         ThingTypeUID thingTypeUID = THING_TYPE_EMBY_CONTROLLER;
         if (DeviceID != null) {
             return new ThingUID(thingTypeUID, DeviceID);
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/discovery/EmbyClientDiscoveryService.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/discovery/EmbyClientDiscoveryService.java
index f45269c607b13..03dbbaa4873f7 100644
--- a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/discovery/EmbyClientDiscoveryService.java
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/discovery/EmbyClientDiscoveryService.java
@@ -19,17 +19,16 @@
 import java.util.Map;
 import java.util.Set;
 
+import org.eclipse.jdt.annotation.NonNullByDefault;
 import org.eclipse.jdt.annotation.Nullable;
 import org.eclipse.smarthome.config.discovery.AbstractDiscoveryService;
 import org.eclipse.smarthome.config.discovery.DiscoveryResult;
 import org.eclipse.smarthome.config.discovery.DiscoveryResultBuilder;
-import org.eclipse.smarthome.config.discovery.DiscoveryService;
 import org.eclipse.smarthome.core.thing.ThingTypeUID;
 import org.eclipse.smarthome.core.thing.ThingUID;
 import org.openhab.binding.emby.internal.handler.EmbyBridgeHandler;
 import org.openhab.binding.emby.internal.model.EmbyPlayStateModel;
 import org.openhab.binding.emby.internal.protocol.EmbyDeviceEncoder;
-import org.osgi.service.component.annotations.Component;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -40,18 +39,13 @@
  *
  * @author Zachary Christiansen - Initial contribution
  */
-@Component(service = DiscoveryService.class, immediate = true, configurationPid = "discovery.emby")
+@NonNullByDefault
+// @Component(service = DiscoveryService.class, immediate = true, configurationPid = "discovery.embyclient")
 public class EmbyClientDiscoveryService extends AbstractDiscoveryService {
     private final Logger logger = LoggerFactory.getLogger(EmbyClientDiscoveryService.class);
     private static final Set<ThingTypeUID> SUPPORTED_THING_TYPES_UIDS = Collections.singleton(THING_TYPE_EMBY_DEVICE);
-
     private final EmbyBridgeHandler embyBridgeHandler;
 
-    public EmbyClientDiscoveryService() {
-        super(SUPPORTED_THING_TYPES_UIDS, 10, false);
-        this.embyBridgeHandler = null;
-    }
-
     public EmbyClientDiscoveryService(EmbyBridgeHandler embyBridgeHandler) {
         super(SUPPORTED_THING_TYPES_UIDS, 10, true);
         this.embyBridgeHandler = embyBridgeHandler;
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/handler/EmbyBridgeHandler.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/handler/EmbyBridgeHandler.java
index 41310a41e25c7..f331e7bb94406 100644
--- a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/handler/EmbyBridgeHandler.java
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/handler/EmbyBridgeHandler.java
@@ -17,13 +17,14 @@
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
 import org.eclipse.smarthome.core.thing.Bridge;
 import org.eclipse.smarthome.core.thing.ChannelUID;
 import org.eclipse.smarthome.core.thing.ThingStatus;
 import org.eclipse.smarthome.core.thing.ThingStatusDetail;
 import org.eclipse.smarthome.core.thing.binding.BaseBridgeHandler;
 import org.eclipse.smarthome.core.types.Command;
-import org.openhab.binding.emby.internal.EmbyBridgeConfiguration;
 import org.openhab.binding.emby.internal.EmbyBridgeListener;
 import org.openhab.binding.emby.internal.discovery.EmbyClientDiscoveryService;
 import org.openhab.binding.emby.internal.model.EmbyPlayStateModel;
@@ -39,25 +40,23 @@
  *
  * @author Zachary Christiansen - Initial contribution
  */
-
+@NonNullByDefault
 public class EmbyBridgeHandler extends BaseBridgeHandler implements EmbyBridgeListener {
 
     private final Logger logger = LoggerFactory.getLogger(EmbyBridgeHandler.class);
 
-    private EmbyBridgeConfiguration config;
     private volatile EmbyConnection connection; // volatile because accessed from multiple threads
-    private ScheduledFuture<?> connectionCheckerFuture;
-    private String callbackIpAddress = null;
-    private EmbyClientDiscoveryService clientDiscoverySerivce;
+    private @Nullable ScheduledFuture<?> connectionCheckerFuture;
+    private @Nullable String callbackIpAddress = null;
+    private @Nullable EmbyClientDiscoveryService clientDiscoverySerivce;
     private EmbyHTTPUtils httputils;
 
-    public EmbyBridgeHandler(Bridge bridge, String hostAddress, String port) {
+    public EmbyBridgeHandler(Bridge bridge, @Nullable String hostAddress, @Nullable String port) {
         super(bridge);
-        connection = new EmbyConnection(this);
         callbackIpAddress = hostAddress + ":" + port;
         logger.debug("The callback ip address is: {}", callbackIpAddress);
-
         httputils = new EmbyHTTPUtils(30, (String) this.getConfig().get(API_KEY), getServerAddress());
+        connection = new EmbyConnection(this);
     }
 
     public void sendCommand(String commandURL, String payload) {
@@ -95,7 +94,6 @@ private int getIntConfigParameter(String key, int defaultValue) {
 
     @Override
     public void initialize() {
-        config = getConfigAs(EmbyBridgeConfiguration.class);
         updateStatus(ThingStatus.UNKNOWN);
         // Example for background initialization:
         scheduler.execute(() -> {
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/handler/EmbyDeviceHandler.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/handler/EmbyDeviceHandler.java
index 24ef95bc4c5f8..05dc749125d53 100644
--- a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/handler/EmbyDeviceHandler.java
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/handler/EmbyDeviceHandler.java
@@ -18,16 +18,15 @@
 
 import java.net.URI;
 import java.net.URISyntaxException;
-import java.util.List;
-import java.util.stream.Collectors;
 
 import javax.measure.Unit;
 
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
 import org.eclipse.smarthome.config.core.Configuration;
 import org.eclipse.smarthome.core.library.types.OnOffType;
 import org.eclipse.smarthome.core.library.types.PlayPauseType;
 import org.eclipse.smarthome.core.library.types.QuantityType;
-import org.eclipse.smarthome.core.library.types.RawType;
 import org.eclipse.smarthome.core.library.types.RewindFastforwardType;
 import org.eclipse.smarthome.core.library.types.StringType;
 import org.eclipse.smarthome.core.library.unit.SmartHomeUnits;
@@ -53,16 +52,18 @@
  *
  * @author Zachary Christiansen - Initial contribution
  */
-
+@NonNullByDefault
 public class EmbyDeviceHandler extends BaseThingHandler implements EmbyEventListener {
 
     private final Logger logger = LoggerFactory.getLogger(EmbyDeviceHandler.class);
 
     private EmbyDeviceConfiguration config;
-    private EmbyPlayStateModel currentPlayState = null;
+    private @Nullable EmbyPlayStateModel currentPlayState = null;
+    private @Nullable EmbyBridgeHandler bridgeHandler;
 
     public EmbyDeviceHandler(Thing thing) {
         super(thing);
+        config = validateConfiguration();
     }
 
     @Override
@@ -70,72 +71,105 @@ public void handleCommand(ChannelUID channelUID, Command command) {
         // if we are in an active playstate then processs the command
         Channel channel = this.thing.getChannel(channelUID.getId());
         String commandName;
-        if (!(this.currentPlayState == null)) {
-            EmbyBridgeHandler handler = (EmbyBridgeHandler) this.getBridge().getHandler();
-            switch (channelUID.getId()) {
-                case CHANNEL_CONTROL:
-                    if (command instanceof PlayPauseType) {
-                        // if we are unpause
-                        if (PlayPauseType.PLAY.equals(command)) {
-                            handler.sendCommand(CONTROL_SESSION + currentPlayState.getId() + CONTROL_PLAY);
-                            // send the pause command
+        if (!(bridgeHandler == null)) {
+            EmbyBridgeHandler handler = bridgeHandler;
+            if (!(currentPlayState == null)) {
+                String currentPlayStateID = currentPlayState.getId();
+                switch (channelUID.getId()) {
+                    case CHANNEL_CONTROL:
+                        if (command instanceof PlayPauseType) {
+                            // if we are unpause
+                            if (PlayPauseType.PLAY.equals(command)) {
+                                handler.sendCommand(CONTROL_SESSION + currentPlayStateID + CONTROL_PLAY);
+                                // send the pause command
+                            } else {
+                                handler.sendCommand(CONTROL_SESSION + currentPlayStateID + CONTROL_PAUSE);
+                            }
                         } else {
-                            handler.sendCommand(CONTROL_SESSION + currentPlayState.getId() + CONTROL_PAUSE);
+                            logger.debug("The channel {} receceived a command {}, this command not supported",
+                                    channelUID.getAsString(), command.toString());
                         }
-                    } else {
-                        logger.debug("The channel {} receceived a command {}, this command not supported",
-                                channelUID.getAsString(), command.toString());
-                    }
-                    break;
-                case CHANNEL_MUTE:
-                    if (OnOffType.ON.equals(command)) {
-                        handler.sendCommand(CONTROL_SESSION + currentPlayState.getId() + CONTROL_MUTE);
-                    } else {
-                        handler.sendCommand(CONTROL_SESSION + currentPlayState.getId() + CONTROL_UNMUTE);
-                    }
-                    break;
-                case CHANNEL_STOP:
-                    if (OnOffType.ON.equals(command)) {
-                        handler.sendCommand(CONTROL_SESSION + currentPlayState.getId() + CONTROL_STOP);
-                    }
-                    break;
-
-                case CHANNEL_SENDPLAYCOMMAND:
-                    logger.debug("Sending the following payload: {} for device: {}", command.toString(),
-                            currentPlayState.getId());
-                    handler.sendCommand(CONTROL_SESSION + currentPlayState.getId() + CONTROL_SENDPLAY,
-                            command.toString());
-                    break;
-
-                case CHANNEL_GENERALCOMMAND:
-                    commandName = channel.getConfiguration().get(CHANNEL_GENERALCOMMAND_NAME).toString();
-                    logger.debug("Sending the following command {} for device: {}", commandName,
-                            currentPlayState.getId());
-                    if (OnOffType.ON.equals(command)) {
-                        handler.sendCommand(
-                                CONTROL_SESSION + currentPlayState.getId() + CONTROL_GENERALCOMMAND + commandName);
-                    }
-                    break;
-                case CHANNEL_GENERALCOMMANDWITHARGS:
-                    commandName = channel.getConfiguration().get(CHANNEL_GENERALCOMMAND_NAME).toString();
-                    logger.debug("Sending the following command {} for device: {}", commandName,
-                            currentPlayState.getId());
-                    handler.sendCommand(
-                            CONTROL_SESSION + currentPlayState.getId() + CONTROL_GENERALCOMMAND + commandName,
-                            "Arguments:" + command + "}");
-                    break;
+                        break;
+                    case CHANNEL_MUTE:
+                        if (OnOffType.ON.equals(command)) {
+                            handler.sendCommand(CONTROL_SESSION + currentPlayStateID + CONTROL_MUTE);
+                        } else {
+                            handler.sendCommand(CONTROL_SESSION + currentPlayStateID + CONTROL_UNMUTE);
+                        }
+                        break;
+                    case CHANNEL_STOP:
+                        if (OnOffType.ON.equals(command)) {
+                            handler.sendCommand(CONTROL_SESSION + currentPlayStateID + CONTROL_STOP);
+                        }
+                        break;
+
+                    case CHANNEL_SENDPLAYCOMMAND:
+                        logger.debug("Sending the following payload: {} for device: {}", command.toString(),
+                                currentPlayStateID);
+                        handler.sendCommand(CONTROL_SESSION + currentPlayStateID + CONTROL_SENDPLAY,
+                                command.toString());
+                        break;
+
+                    case CHANNEL_GENERALCOMMAND:
+                        commandName = channel.getConfiguration().get(CHANNEL_GENERALCOMMAND_NAME).toString();
+                        logger.debug("Sending the following command {} for device: {}", commandName,
+                                currentPlayStateID);
+                        if (OnOffType.ON.equals(command)) {
+                            handler.sendCommand(
+                                    CONTROL_SESSION + currentPlayStateID + CONTROL_GENERALCOMMAND + commandName);
+                        }
+                        break;
+                    case CHANNEL_GENERALCOMMANDWITHARGS:
+                        commandName = channel.getConfiguration().get(CHANNEL_GENERALCOMMAND_NAME).toString();
+                        logger.debug("Sending the following command {} for device: {}", commandName,
+                                currentPlayStateID);
+                        handler.sendCommand(CONTROL_SESSION + currentPlayStateID + CONTROL_GENERALCOMMAND + commandName,
+                                "Arguments:" + command + "}");
+                        break;
+                }
             }
+        } else {
+            updateStatus(OFFLINE, CONFIGURATION_ERROR,
+                    "Unable to handle command, You must choose a Emby Server for this Device.");
         }
     }
 
+    private EmbyDeviceConfiguration validateConfiguration() {
+        EmbyDeviceConfiguration embyDeviceConfig = new EmbyDeviceConfiguration(
+                this.thing.getConfiguration().get(DEVICE_ID).toString());
+        Configuration testConfig = this.thing.getChannel(CHANNEL_IMAGEURL).getConfiguration();
+        if (!(testConfig.get(CHANNEL_IMAGEURL_MAXWIDTH) == null)) {
+            embyDeviceConfig.imageMaxWidth = testConfig.get(CHANNEL_IMAGEURL_MAXWIDTH).toString();
+        }
+        if (!(testConfig.get(CHANNEL_IMAGEURL_MAXHEIGHT) == null)) {
+            embyDeviceConfig.imageMaxHeight = testConfig.get(CHANNEL_IMAGEURL_MAXHEIGHT).toString();
+        }
+        String testPercentPlayed = "true";
+        if (!(testConfig.get(CHANNEL_IMAGEURL_PERCENTPLAYED) == null)) {
+            testPercentPlayed = testConfig.get(CHANNEL_IMAGEURL_PERCENTPLAYED).toString();
+        }
+
+        embyDeviceConfig.imageImageType = testConfig.get(CHANNEL_IMAGEURL_TYPE).toString();
+
+        if ((testPercentPlayed.equals("true"))) {
+            embyDeviceConfig.imagePercentPlayed = true;
+        } else {
+            embyDeviceConfig.imagePercentPlayed = false;
+        }
+
+        return embyDeviceConfig;
+
+    }
+
     @Override
     public void initialize() {
         logger.debug("Initializing emby device: {}", this.getThing().getLabel());
-        config = getConfigAs(EmbyDeviceConfiguration.class);
+        config = validateConfiguration();
         updateStatus(ThingStatus.UNKNOWN);
         Bridge bridge = getBridge();
         if (bridge == null || bridge.getHandler() == null || !(bridge.getHandler() instanceof EmbyBridgeHandler)) {
-            updateStatus(OFFLINE, CONFIGURATION_ERROR, "You must choose a Emby Server for this Device.");
+            updateStatus(OFFLINE, CONFIGURATION_ERROR,
+                    "Can't initialize thing, You must choose a Emby Server for this Device.");
             return;
         }
 
@@ -144,6 +178,7 @@ public void initialize() {
             return;
         }
         updateStatus(ThingStatus.ONLINE);
+        bridgeHandler = (EmbyBridgeHandler) bridge.getHandler();
     }
 
     @Override
@@ -228,7 +263,7 @@ public void updateDuration(long duration) {
     /**
      * Wrap the given String in a new {@link StringType} or returns {@link UnDefType#UNDEF} if the String is empty.
      */
-    private State createStringState(String string) {
+    private State createStringState(@Nullable String string) {
         if (string == null || string.isEmpty()) {
             return UnDefType.UNDEF;
         } else {
@@ -236,36 +271,12 @@ private State createStringState(String string) {
         }
     }
 
-    /**
-     * Wrap the given list of Strings in a new {@link StringType} or returns {@link UnDefType#UNDEF} if the list of
-     * Strings is empty.
-     */
-    private State createStringListState(List<String> list) {
-        if (list == null || list.isEmpty()) {
-            return UnDefType.UNDEF;
-        } else {
-            return createStringState(list.stream().collect(Collectors.joining(", ")));
-        }
-    }
-
-    /**
-     * Wrap the given RawType and return it as {@link State} or return {@link UnDefType#UNDEF} if the RawType is null.
-     */
-    private State createImageState(RawType image) {
-        if (image == null) {
-            return UnDefType.UNDEF;
-        } else {
-            return image;
-        }
-    }
-
-    private State createQuantityState(Number value, Unit<?> unit) {
+    private State createQuantityState(@Nullable Number value, Unit<?> unit) {
         return (value == null) ? UnDefType.UNDEF : new QuantityType<>(value, unit);
     }
 
     private void updateState(EmbyState state) {
         updatePlayerState(state);
-
         // if this is a Stop then clear everything else
         if (state == EmbyState.STOP) {
             updateTitle("");
@@ -276,7 +287,6 @@ private void updateState(EmbyState state) {
             this.currentPlayState = null;
             updateCurrentTime(-1);
         }
-
     }
 
     @Override
@@ -286,44 +296,9 @@ public void handleEvent(EmbyPlayStateModel playstate, String hostname, int embyp
             this.currentPlayState = playstate;
             logger.debug("the deviceId for: {} matches the deviceId of the thing so we will update stringUrl",
                     playstate.getDeviceName());
-            Configuration config = this.thing.getChannel(CHANNEL_IMAGEURL).getConfiguration();
-            String maxWidth = null;
-            String maxHeight = null;
-            Boolean percentPlayed = null;
-
-            // String maxWidth = config.get(CHANNEL_IMAGEURL_MAXWIDTH).toString();
-            // String maxHeight = config.get(CHANNEL_IMAGEURL_MAXHEIGHT).toString();
-            // Boolean percentPlayed = (Boolean) config.get(CHANNEL_IMAGEURL_PERCENTPLAYED);
-            // if (percentPlayed == null) {
-            // percentPlayed = true;
-            // }
-
-            try {
-                maxWidth = this.thing.getChannel(CHANNEL_IMAGEURL).getConfiguration().get(CHANNEL_IMAGEURL_MAXWIDTH)
-                        .toString();
-            } catch (NullPointerException e) {
-                logger.debug("The maxWidth was not set so we keep value as null");
-            }
-
-            try {
-                maxHeight = this.thing.getChannel(CHANNEL_IMAGEURL).getConfiguration().get(CHANNEL_IMAGEURL_MAXHEIGHT)
-                        .toString();
-            } catch (NullPointerException e) {
-                logger.debug("The maxHeight was not set so we keep value as null");
-            }
-            try {
-                percentPlayed = (Boolean) this.thing.getChannel(CHANNEL_IMAGEURL).getConfiguration()
-                        .get(CHANNEL_IMAGEURL_PERCENTPLAYED);
-                if (percentPlayed == null) {
-                    percentPlayed = true;
-                }
-            } catch (NullPointerException e) {
-                logger.debug("The Percent Played setting was not set so we keep value as true");
-            }
-
             try {
-                URI imageURI = playstate.getPrimaryImageURL(hostname, embyport,
-                        config.get(CHANNEL_IMAGEURL_TYPE).toString(), maxWidth, maxHeight, percentPlayed);
+                URI imageURI = playstate.getPrimaryImageURL(hostname, embyport, config.imageImageType,
+                        config.imageMaxWidth, config.imageMaxHeight, config.imagePercentPlayed);
                 if (imageURI.getHost().equals("NotPlaying")) {
                     updateState(EmbyState.END);
                     updateState(EmbyState.STOP);
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyClientSocket.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyClientSocket.java
index d76c02e0ba77d..902f26bd542f0 100644
--- a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyClientSocket.java
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyClientSocket.java
@@ -20,6 +20,8 @@
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
 import org.eclipse.jetty.websocket.api.Session;
 import org.eclipse.jetty.websocket.api.annotations.OnWebSocketClose;
 import org.eclipse.jetty.websocket.api.annotations.OnWebSocketConnect;
@@ -46,6 +48,7 @@
  * @author Zachary Christiansen - Initial contribution
  *
  */
+@NonNullByDefault
 public class EmbyClientSocket {
 
     private final Logger logger = LoggerFactory.getLogger(EmbyClientSocket.class);
@@ -53,27 +56,27 @@ public class EmbyClientSocket {
     private final ScheduledExecutorService scheduler;
     private static final int REQUEST_TIMEOUT_MS = 60000;
 
-    private CountDownLatch commandLatch = null;
-    private JsonObject commandResponse = null;
+    private @Nullable CountDownLatch commandLatch = null;
+    private @Nullable JsonObject commandResponse = null;
 
     private boolean connected = false;
 
     private final JsonParser parser = new JsonParser();
     private final Gson mapper = new Gson();
-    private URI uri;
-    private Session session;
+    private @Nullable URI uri;
+    private @Nullable Session session;
     private WebSocketClient client;
     private int bufferSize;
 
     private final EmbyClientSocketEventListener eventHandler;
 
-    public EmbyClientSocket(EmbyClientSocketEventListener eventHandler, URI uri, ScheduledExecutorService scheduler,
-            int buffersize) {
-        this.eventHandler = eventHandler;
-        this.uri = uri;
+    public EmbyClientSocket(EmbyClientSocketEventListener setEventHandler, @Nullable URI setUri,
+            ScheduledExecutorService setScheduler, int setBufferSize) {
+        eventHandler = setEventHandler;
+        uri = setUri;
         client = new WebSocketClient();
-        this.scheduler = scheduler;
-        this.bufferSize = buffersize;
+        scheduler = setScheduler;
+        bufferSize = setBufferSize;
     }
 
     /**
@@ -125,6 +128,7 @@ public boolean isConnected() {
     }
 
     @WebSocket
+    @NonNullByDefault
     public class EmbyWebSocketListener {
         @OnWebSocketConnect
         public void onConnect(Session wssession) {
@@ -194,18 +198,18 @@ private void sendMessage(String str) throws IOException {
         }
     }
 
-    public JsonElement callMethod(String methodName) {
+    public @Nullable JsonElement callMethod(String methodName) {
         return callMethod(methodName, null);
     }
 
-    public JsonElement callMethodString(String methodName, String dataParams) {
+    public @Nullable JsonElement callMethodString(String methodName, String dataParams) {
         JsonObject payloadObject = new JsonObject();
         payloadObject.addProperty("MessageType", methodName);
         payloadObject.addProperty("Data", dataParams);
         return callMethod(payloadObject);
     }
 
-    public JsonElement callMethod(String methodName, JsonObject params) {
+    public @Nullable JsonElement callMethod(String methodName, @Nullable JsonObject params) {
         JsonObject payloadObject = new JsonObject();
         // payloadObject.addProperty("jsonrpc", "2.0");
         // payloadObject.addProperty("id", nextMessageId);
@@ -216,7 +220,7 @@ public JsonElement callMethod(String methodName, JsonObject params) {
         return callMethod(payloadObject);
     }
 
-    public synchronized JsonElement callMethod(JsonObject payloadObject) {
+    public synchronized @Nullable JsonElement callMethod(JsonObject payloadObject) {
         try {
             String message = mapper.toJson(payloadObject);
             commandLatch = new CountDownLatch(1);
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyClientSocketEventListener.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyClientSocketEventListener.java
index aa3d05e1a206a..6640ec261b017 100644
--- a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyClientSocketEventListener.java
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyClientSocketEventListener.java
@@ -12,6 +12,7 @@
  */
 package org.openhab.binding.emby.internal.protocol;
 
+import org.eclipse.jdt.annotation.NonNullByDefault;
 import org.openhab.binding.emby.internal.model.EmbyPlayStateModel;
 
 /**
@@ -20,6 +21,7 @@
  * @author Zachary Christiansen - Initial contribution
  *
  */
+@NonNullByDefault
 public interface EmbyClientSocketEventListener {
 
     void handleEvent(EmbyPlayStateModel playstate);
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyConnection.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyConnection.java
index ecdd5a8b73bc1..ce4c7bef1a740 100644
--- a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyConnection.java
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyConnection.java
@@ -16,6 +16,8 @@
 import java.net.URISyntaxException;
 import java.util.concurrent.ScheduledExecutorService;
 
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
 import org.openhab.binding.emby.internal.EmbyBridgeListener;
 import org.openhab.binding.emby.internal.model.EmbyPlayStateModel;
 import org.slf4j.Logger;
@@ -26,7 +28,7 @@
  *
  * @author Zachary Christiansen - Initial contribution
  */
-
+@NonNullByDefault
 public class EmbyConnection implements EmbyClientSocketEventListener {
 
     private final Logger logger = LoggerFactory.getLogger(EmbyConnection.class);
@@ -34,14 +36,14 @@ public class EmbyConnection implements EmbyClientSocketEventListener {
     private int refreshRate;
     private String hostname;
     private int embyport;
-    private URI wsUri;
-    private EmbyClientSocket socket;
+    private @Nullable URI wsUri;
+    private @Nullable EmbyClientSocket socket;
 
     private final EmbyBridgeListener listener;
 
     public EmbyConnection(EmbyBridgeListener listener) {
         this.listener = listener;
-
+        this.hostname = "";
     }
 
     @Override
@@ -56,19 +58,19 @@ public synchronized void onConnectionOpened() {
         socket.callMethodString("SessionsStart", "0," + Integer.toString(this.refreshRate));
     }
 
-    public synchronized void connect(String hostname, int port, String apiKey, ScheduledExecutorService scheduler,
+    public synchronized void connect(String setHostName, int port, String apiKey, ScheduledExecutorService scheduler,
             int refreshRate, int bufferSize) {
-        this.hostname = hostname;
+        this.hostname = setHostName;
         this.embyport = port;
         this.refreshRate = refreshRate;
         try {
             close();
 
-            wsUri = new URI("ws", null, hostname, port, null, "api_key=" + apiKey, null);
+            wsUri = new URI("ws", null, hostname, embyport, null, "api_key=" + apiKey, null);
             socket = new EmbyClientSocket(this, wsUri, scheduler, bufferSize);
             checkConnection();
         } catch (URISyntaxException e) {
-            logger.error("exception during constructing URI host={}, port={}", hostname, port, e);
+            logger.error("exception during constructing URI host={}, port={}", hostname, embyport, e);
         }
     }
 
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyDeviceEncoder.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyDeviceEncoder.java
index c00aa37d763f7..2c16469822a2e 100644
--- a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyDeviceEncoder.java
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyDeviceEncoder.java
@@ -12,8 +12,7 @@
  */
 package org.openhab.binding.emby.internal.protocol;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import org.eclipse.jdt.annotation.NonNullByDefault;
 
 /**
  * EmbyClientSocket implements the low level communication to Emby through
@@ -22,10 +21,9 @@
  * @author Zachary Christiansen - Initial contribution
  *
  */
+@NonNullByDefault
 public class EmbyDeviceEncoder {
 
-    private final Logger logger = LoggerFactory.getLogger(EmbyDeviceEncoder.class);
-
     public String encodeDeviceID(String deviceID) {
         return deviceID.replaceAll("[^A-Za-z0-9]", "UYHJKU");
     }
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyHTTPUtils.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyHTTPUtils.java
index daa6c6a23f501..4138436bc3d73 100644
--- a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyHTTPUtils.java
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyHTTPUtils.java
@@ -18,6 +18,8 @@
 import java.util.Properties;
 import java.util.concurrent.TimeUnit;
 
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
 import org.eclipse.smarthome.io.net.http.HttpUtil;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -27,6 +29,7 @@
  *
  * @author Zachary Christiansen - Initial contribution
  */
+@NonNullByDefault
 public class EmbyHTTPUtils {
     private final Logger logger = LoggerFactory.getLogger(EmbyHTTPUtils.class);
     private int requestTimeout;
@@ -74,7 +77,8 @@ protected Properties getHttpHeaders() {
      * @param payload the json payload you want to send as part of the request
      * @param retry the number of retries before throwing the IOexpcetion back to the handler
      */
-    public synchronized String doPost(String urlAddress, String payload, int retryCount) throws EmbyHttpRetryExceeded {
+    public synchronized @Nullable String doPost(String urlAddress, String payload, int retryCount)
+            throws EmbyHttpRetryExceeded {
         String response = null;
         int x = 0;
         Boolean loop = true;
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyHttpRetryExceeded.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyHttpRetryExceeded.java
index f47dc15ba7a64..29960997a3044 100644
--- a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyHttpRetryExceeded.java
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/protocol/EmbyHttpRetryExceeded.java
@@ -12,12 +12,15 @@
  */
 package org.openhab.binding.emby.internal.protocol;
 
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
 /**
  * Custom exception class to be thrown when number of retries is exceeded.
  *
  * @author Zachary Christiansen - Initial contribution
  */
 @SuppressWarnings("serial")
+@NonNullByDefault
 public class EmbyHttpRetryExceeded extends Exception {
     public EmbyHttpRetryExceeded(String message, Throwable cause) {
         super(message, cause);

From b360164cbcd2940c24726483aeb468fdd40c04da Mon Sep 17 00:00:00 2001
From: Zachary Christiansen <volfan6415@gmail.com>
Date: Tue, 1 Sep 2020 16:32:29 -0500
Subject: [PATCH 3/3] -bug fixes -updates to allow for control play command to
 be sent when nothing is actively playing

Signed-off-by: Zachary Christiansen <volfan6415@gmail.com>
---
 .../internal/handler/EmbyBridgeHandler.java   | 10 +++++
 .../internal/handler/EmbyDeviceHandler.java   | 34 +++++++++--------
 .../model/EmbyNowPlayingCurrentProgram.java   | 38 +++++++++++++++++++
 .../internal/model/EmbyNowPlayingItem.java    | 21 ++++++++--
 .../internal/model/EmbyPlayStateModel.java    | 11 +++++-
 .../resources/ESH-INF/thing/thing-types.xml   |  2 +-
 6 files changed, 93 insertions(+), 23 deletions(-)
 create mode 100644 bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyNowPlayingCurrentProgram.java

diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/handler/EmbyBridgeHandler.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/handler/EmbyBridgeHandler.java
index f331e7bb94406..5a991bf7c3606 100644
--- a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/handler/EmbyBridgeHandler.java
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/handler/EmbyBridgeHandler.java
@@ -75,6 +75,16 @@ public void sendCommand(String commandURL) {
         }
     }
 
+    @Nullable
+    public String sendCommandWithReturn(String commandURL) {
+        try {
+            return httputils.doPost(commandURL, "", 2);
+        } catch (EmbyHttpRetryExceeded e) {
+            logger.debug("The number of retry attempts was exceeded", e.getCause());
+            return null;
+        }
+    }
+
     private String getServerAddress() {
         String host = getConfig().get(HOST_PARAMETER).toString();
         String port = Integer.toString(getIntConfigParameter(WS_PORT_PARAMETER, 8096));
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/handler/EmbyDeviceHandler.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/handler/EmbyDeviceHandler.java
index 05dc749125d53..24fa0eef0119d 100644
--- a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/handler/EmbyDeviceHandler.java
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/handler/EmbyDeviceHandler.java
@@ -46,6 +46,8 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import com.google.gson.JsonParser;
+
 /**
  * The {@link EmbyDeviceHandler} is responsible for handling commands, which are
  * sent to one of the channels.
@@ -56,6 +58,7 @@
 public class EmbyDeviceHandler extends BaseThingHandler implements EmbyEventListener {
 
     private final Logger logger = LoggerFactory.getLogger(EmbyDeviceHandler.class);
+    private final JsonParser parser = new JsonParser();
 
     private EmbyDeviceConfiguration config;
     private @Nullable EmbyPlayStateModel currentPlayState = null;
@@ -73,17 +76,19 @@ public void handleCommand(ChannelUID channelUID, Command command) {
         String commandName;
         if (!(bridgeHandler == null)) {
             EmbyBridgeHandler handler = bridgeHandler;
+            logger.debug("The channel ID of the received command is: {}", channelUID.getId());
             if (!(currentPlayState == null)) {
-                String currentPlayStateID = currentPlayState.getId();
+                String currentSessionID = currentPlayState.getId();
+                logger.debug("The device Id is: {}, the received deviceID is: {} ", currentSessionID, config.deviceID);
                 switch (channelUID.getId()) {
                     case CHANNEL_CONTROL:
                         if (command instanceof PlayPauseType) {
                             // if we are unpause
                             if (PlayPauseType.PLAY.equals(command)) {
-                                handler.sendCommand(CONTROL_SESSION + currentPlayStateID + CONTROL_PLAY);
+                                handler.sendCommand(CONTROL_SESSION + currentSessionID + CONTROL_PLAY);
                                 // send the pause command
                             } else {
-                                handler.sendCommand(CONTROL_SESSION + currentPlayStateID + CONTROL_PAUSE);
+                                handler.sendCommand(CONTROL_SESSION + currentSessionID + CONTROL_PAUSE);
                             }
                         } else {
                             logger.debug("The channel {} receceived a command {}, this command not supported",
@@ -92,42 +97,40 @@ public void handleCommand(ChannelUID channelUID, Command command) {
                         break;
                     case CHANNEL_MUTE:
                         if (OnOffType.ON.equals(command)) {
-                            handler.sendCommand(CONTROL_SESSION + currentPlayStateID + CONTROL_MUTE);
+                            handler.sendCommand(CONTROL_SESSION + currentSessionID + CONTROL_MUTE);
                         } else {
-                            handler.sendCommand(CONTROL_SESSION + currentPlayStateID + CONTROL_UNMUTE);
+                            handler.sendCommand(CONTROL_SESSION + currentSessionID + CONTROL_UNMUTE);
                         }
                         break;
                     case CHANNEL_STOP:
                         if (OnOffType.ON.equals(command)) {
-                            handler.sendCommand(CONTROL_SESSION + currentPlayStateID + CONTROL_STOP);
+                            handler.sendCommand(CONTROL_SESSION + currentSessionID + CONTROL_STOP);
                         }
                         break;
 
                     case CHANNEL_SENDPLAYCOMMAND:
                         logger.debug("Sending the following payload: {} for device: {}", command.toString(),
-                                currentPlayStateID);
-                        handler.sendCommand(CONTROL_SESSION + currentPlayStateID + CONTROL_SENDPLAY,
-                                command.toString());
+                                currentSessionID);
+                        handler.sendCommand(CONTROL_SESSION + currentSessionID + CONTROL_SENDPLAY, command.toString());
                         break;
 
                     case CHANNEL_GENERALCOMMAND:
                         commandName = channel.getConfiguration().get(CHANNEL_GENERALCOMMAND_NAME).toString();
-                        logger.debug("Sending the following command {} for device: {}", commandName,
-                                currentPlayStateID);
+                        logger.debug("Sending the following command {} for device: {}", commandName, currentSessionID);
                         if (OnOffType.ON.equals(command)) {
                             handler.sendCommand(
-                                    CONTROL_SESSION + currentPlayStateID + CONTROL_GENERALCOMMAND + commandName);
+                                    CONTROL_SESSION + currentSessionID + CONTROL_GENERALCOMMAND + commandName);
                         }
                         break;
                     case CHANNEL_GENERALCOMMANDWITHARGS:
                         commandName = channel.getConfiguration().get(CHANNEL_GENERALCOMMAND_NAME).toString();
-                        logger.debug("Sending the following command {} for device: {}", commandName,
-                                currentPlayStateID);
-                        handler.sendCommand(CONTROL_SESSION + currentPlayStateID + CONTROL_GENERALCOMMAND + commandName,
+                        logger.debug("Sending the following command {} for device: {}", commandName, currentSessionID);
+                        handler.sendCommand(CONTROL_SESSION + currentSessionID + CONTROL_GENERALCOMMAND + commandName,
                                 "Arguments:" + command + "}");
                         break;
                 }
             }
+
         } else {
             updateStatus(OFFLINE, CONFIGURATION_ERROR,
                     "Unable to handle command, You must choose a Emby Server for this Device.");
@@ -284,7 +287,6 @@ private void updateState(EmbyState state) {
             updatePrimaryImageURL("");
             updateMediaType("");
             updateDuration(-1);
-            this.currentPlayState = null;
             updateCurrentTime(-1);
         }
     }
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyNowPlayingCurrentProgram.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyNowPlayingCurrentProgram.java
new file mode 100644
index 0000000000000..9ca72a8731747
--- /dev/null
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyNowPlayingCurrentProgram.java
@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.emby.internal.model;
+
+import java.math.BigDecimal;
+
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * embyPlayState - part of the model for the json object received from the server
+ *
+ * @author Zachary Christiansen - Initial Contribution
+ *
+ */
+public class EmbyNowPlayingCurrentProgram {
+
+    @SerializedName("RunTimeTicks")
+    private BigDecimal runTimeTicks;
+
+    /**
+     * @return the run time of the item
+     */
+    BigDecimal getRunTimeTicks() {
+        return runTimeTicks;
+
+    }
+
+}
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyNowPlayingItem.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyNowPlayingItem.java
index b87f82c32527b..0eb32e3c817cf 100644
--- a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyNowPlayingItem.java
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyNowPlayingItem.java
@@ -14,6 +14,9 @@
 
 import java.math.BigDecimal;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import com.google.gson.annotations.SerializedName;
 
 /**
@@ -38,6 +41,9 @@ public class EmbyNowPlayingItem {
     private String seasonId;
     @SerializedName("Type")
     private String nowPlayingType;
+    @SerializedName("CurrentProgram")
+    private EmbyNowPlayingCurrentProgram currentProgram;
+    private final Logger logger = LoggerFactory.getLogger(EmbyNowPlayingItem.class);
 
     String getName() {
         return name;
@@ -54,8 +60,11 @@ String getNowPlayingType() {
     }
 
     String getOriginalTitle() {
-        return originalTitle;
-
+        if (originalTitle.isEmpty()) {
+            return name;
+        } else {
+            return originalTitle;
+        }
     }
 
     /**
@@ -70,8 +79,12 @@ String getId() {
      * @return the total runtime ticks of the currently playing item
      */
     BigDecimal getRunTimeTicks() {
-        return runTimeTicks;
-
+        logger.debug("the media type is {}", nowPlayingType);
+        if (nowPlayingType.contains("TvChannel")) {
+            return currentProgram.getRunTimeTicks();
+        } else {
+            return runTimeTicks;
+        }
     }
 
     String getOverview() {
diff --git a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyPlayStateModel.java b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyPlayStateModel.java
index c572a70fb5e17..708dc1b23ccd5 100644
--- a/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyPlayStateModel.java
+++ b/bundles/org.openhab.binding.emby/src/main/java/org/openhab/binding/emby/internal/model/EmbyPlayStateModel.java
@@ -96,8 +96,13 @@ public Boolean compareDeviceId(String compareId) {
      *         mathmatical representation of the percentage played
      */
     public BigDecimal getPercentPlayed() {
-        return (playState.getPositionTicks().divide(nowPlayingItem.getRunTimeTicks(), 2, RoundingMode.HALF_UP));
-
+        // check for zero position ticks if zero return 0% played
+        logger.debug("The play state position is {}", playState.getPositionTicks().toString());
+        if (playState.getPositionTicks().equals(BigDecimal.ZERO)) {
+            return BigDecimal.ZERO;
+        } else {
+            return (playState.getPositionTicks().divide(nowPlayingItem.getRunTimeTicks(), 2, RoundingMode.HALF_UP));
+        }
     }
 
     public EmbyNowPlayingItem getNowPlayingItem() {
@@ -161,11 +166,13 @@ public URI getPrimaryImageURL(String embyHost, int embyPort, String embyType, St
                 imagePath = "/emby/items/" + this.nowPlayingItem.getSeasonId() + "/Images/" + embyType;
             } else {
                 imagePath = "/emby/items/" + this.nowPlayingItem.getId() + "/Images/" + embyType;
+
             }
 
             String query = "";
 
             if (percentPlayed) {
+                logger.debug("The percent Played equals:{}", getPercentPlayed());
                 BigDecimal percentPlayedRounded = getPercentPlayed();
                 double percent = percentPlayedRounded.doubleValue();
                 percent = percent * 100;
diff --git a/bundles/org.openhab.binding.emby/src/main/resources/ESH-INF/thing/thing-types.xml b/bundles/org.openhab.binding.emby/src/main/resources/ESH-INF/thing/thing-types.xml
index 3fa05130001a9..3e6cb2fdd3091 100644
--- a/bundles/org.openhab.binding.emby/src/main/resources/ESH-INF/thing/thing-types.xml
+++ b/bundles/org.openhab.binding.emby/src/main/resources/ESH-INF/thing/thing-types.xml
@@ -31,7 +31,7 @@
 			</parameter>
 		</config-description>
 	</bridge-type>
-	<thing-type id="device" extensible="generalCommand">
+	<thing-type id="device" extensible="generalCommand,generalCommand_withArguments">
 		<supported-bridge-type-refs>
 			<bridge-type-ref id="controller" />
 		</supported-bridge-type-refs>