294 lines
12 KiB
Java
294 lines
12 KiB
Java
/*
|
|
* Copyright 2015 Synced Synapse. All rights reserved.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
package org.xbmc.kore.eventclient;
|
|
|
|
|
|
import android.annotation.SuppressLint;
|
|
import android.os.*;
|
|
import android.os.Process;
|
|
|
|
import org.xbmc.kore.host.HostInfo;
|
|
import org.xbmc.kore.jsonrpc.ApiCallback;
|
|
import org.xbmc.kore.jsonrpc.HostConnection;
|
|
import org.xbmc.kore.jsonrpc.method.Application;
|
|
import org.xbmc.kore.jsonrpc.type.ApplicationType;
|
|
import org.xbmc.kore.utils.LogUtils;
|
|
import org.xbmc.kore.utils.NetUtils;
|
|
import org.xbmc.kore.utils.Utils;
|
|
|
|
import java.io.IOException;
|
|
import java.net.InetAddress;
|
|
import java.net.UnknownHostException;
|
|
|
|
/**
|
|
* Class that establishes and maintains a connection to Kodi's EventServer
|
|
* This class keeps pinging Kodi to keep the connection alive and contains
|
|
* auxiliary methods that allow the sending of packets to Kodi.
|
|
* Make sure to call quit() when done with it, so that it gracefully shuts down
|
|
*/
|
|
public class EventServerConnection {
|
|
private static final String TAG = LogUtils.makeLogTag(EventServerConnection.class);
|
|
|
|
private static final int PING_INTERVAL = 45000; // ms
|
|
private static final String DEVICE_NAME = "Kore Remote";
|
|
|
|
/**
|
|
* Host to connect too
|
|
*/
|
|
private final HostInfo hostInfo;
|
|
private InetAddress hostInetAddress = null;
|
|
|
|
// Handler on which packets will be posted, to send them asynchronously
|
|
private Handler commHandler = null;
|
|
private HandlerThread handlerThread = null;
|
|
|
|
private PacketPING packetPING = new PacketPING();
|
|
private Runnable pingRunnable = new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
LogUtils.LOGD(TAG, "Pinging EventServer");
|
|
if (hostInetAddress != null) {
|
|
try {
|
|
packetPING.send(hostInetAddress, hostInfo.getEventServerPort());
|
|
} catch (IOException exc) {
|
|
LogUtils.LOGD(TAG, "Got an IOException when sending a PING Packet to Kodi's EventServer");
|
|
}
|
|
}
|
|
commHandler.postDelayed(this, PING_INTERVAL);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Interface to notify users if the connection was successful
|
|
*/
|
|
public interface EventServerConnectionCallback {
|
|
void OnConnectResult(boolean success);
|
|
}
|
|
|
|
/**
|
|
* Constructor. Starts the thread that keeps the connection alive. Make sure to call quit() when done.
|
|
* @param hostInfo Host to connect to
|
|
* @param callback Callback to call with the connection result
|
|
* @param callbackHandler Handler on which to call the callback
|
|
*/
|
|
public EventServerConnection(final HostInfo hostInfo,
|
|
final EventServerConnectionCallback callback,
|
|
final Handler callbackHandler) {
|
|
this.hostInfo = hostInfo;
|
|
|
|
LogUtils.LOGD(TAG, "Starting EventServer Thread");
|
|
// Handler thread that will keep pinging and send the requests to Kodi
|
|
handlerThread = new HandlerThread("EventServerConnection", Process.THREAD_PRIORITY_BACKGROUND);
|
|
handlerThread.start();
|
|
|
|
// Get the HandlerThread's Looper and use it for our Handler
|
|
commHandler = new Handler(handlerThread.getLooper());
|
|
|
|
// Now, get the host InetAddress in the background
|
|
commHandler.post(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
try {
|
|
hostInetAddress = NetUtils.getInet4AddressByName(hostInfo.getAddress());
|
|
} catch (UnknownHostException exc) {
|
|
LogUtils.LOGD(TAG, "Got an UnknownHostException, disabling EventServer");
|
|
hostInetAddress = null;
|
|
}
|
|
// Call the callback on the caller's thread
|
|
callbackHandler.post(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
callback.OnConnectResult(hostInetAddress != null);
|
|
}
|
|
});
|
|
if (hostInetAddress != null) {
|
|
// Start pinging
|
|
commHandler.postDelayed(pingRunnable, PING_INTERVAL);
|
|
} else {
|
|
quitHandlerThread(handlerThread);
|
|
}
|
|
}
|
|
});
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* Stops the HandlerThread that is being used to send packets to Kodi
|
|
*/
|
|
public void quit() {
|
|
LogUtils.LOGD(TAG, "Quiting EventServer handler thread");
|
|
quitHandlerThread(handlerThread);
|
|
}
|
|
|
|
/**
|
|
* Sends a packet to Kodi's Event Server
|
|
* Only sends the packet if connected, i.e. if quit() has not been not called
|
|
* @param p Packet to send
|
|
*/
|
|
public void sendPacket(final Packet p) {
|
|
if (!handlerThread.isAlive() || (hostInetAddress == null)) {
|
|
return;
|
|
}
|
|
|
|
LogUtils.LOGD(TAG, "Sending Packet");
|
|
|
|
commHandler.post(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
try {
|
|
p.send(hostInetAddress, hostInfo.getEventServerPort());
|
|
} catch (IOException exc) {
|
|
LogUtils.LOGD(TAG, "Got an IOException when sending a packet to Kodi's EventServer");
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Establishes a connection to the EventServer and reports the result
|
|
* @param hostInfo Host to connect to
|
|
* @param callerCallback Callback on which to post the result
|
|
* @param callerHandler Handler on which to post the callback call
|
|
*/
|
|
public static void testEventServerConnection(final HostInfo hostInfo,
|
|
final EventServerConnectionCallback callerCallback,
|
|
final Handler callerHandler) {
|
|
final HandlerThread auxThread = new HandlerThread("EventServerConnectionTest", Process.THREAD_PRIORITY_DEFAULT);
|
|
auxThread.start();
|
|
|
|
// Get the HandlerThread's Looper and use it for our Handler
|
|
final Handler auxHandler = new Handler(auxThread.getLooper());
|
|
|
|
auxHandler.post(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
// Get the InetAddress
|
|
final InetAddress hostInetAddress;
|
|
try {
|
|
hostInetAddress = NetUtils.getInet4AddressByName(hostInfo.getAddress());
|
|
} catch (UnknownHostException exc) {
|
|
LogUtils.LOGD(TAG, "Couldn't get host InetAddress");
|
|
reportTestResult(callerHandler, callerCallback, false);
|
|
quitHandlerThread(auxThread);
|
|
return;
|
|
}
|
|
|
|
// Send a HELO packet
|
|
Packet p = new PacketHELO(DEVICE_NAME);
|
|
try {
|
|
p.send(hostInetAddress, hostInfo.getEventServerPort());
|
|
} catch (IOException exc) {
|
|
LogUtils.LOGD(TAG, "Couldn't send HELO packet to host");
|
|
reportTestResult(callerHandler, callerCallback, false);
|
|
quitHandlerThread(auxThread);
|
|
return;
|
|
}
|
|
|
|
// The previous checks don't really test the connection, as this is UDP. Apart from checking if
|
|
// any HostUnreachable ICMP message is returned (which may or may not happen), there's no direct way
|
|
// to check if the messages were delivered, so the solution is to force something to happen on
|
|
// Kodi and them read Kodi's state to check if it was applied.
|
|
// We are going to get the mute status of Kodi via jsonrpc, change it via EventServer and check if
|
|
// it was changed via jsonrpc, reverting it back afterwards
|
|
final HostConnection auxHostConnection = new HostConnection(
|
|
new HostInfo(hostInfo.getName(), hostInfo.getAddress(),
|
|
HostConnection.PROTOCOL_HTTP, hostInfo.getHttpPort(), hostInfo.getTcpPort(),
|
|
hostInfo.getUsername(), hostInfo.getPassword(), false, 0, hostInfo.isHttps));
|
|
final Application.GetProperties action = new Application.GetProperties(Application.GetProperties.MUTED);
|
|
final Packet mutePacket = new PacketBUTTON(ButtonCodes.MAP_REMOTE, ButtonCodes.REMOTE_MUTE,
|
|
false, true, true, (short) 0, (byte) 0);
|
|
|
|
// Get the initial mute status
|
|
action.execute(auxHostConnection, new ApiCallback<ApplicationType.PropertyValue>() {
|
|
@Override
|
|
public void onSuccess(ApplicationType.PropertyValue result) {
|
|
final boolean initialMuteStatus = result.muted;
|
|
// Switch mute status
|
|
try {
|
|
mutePacket.send(hostInetAddress, hostInfo.getEventServerPort());
|
|
} catch (IOException exc) {
|
|
LogUtils.LOGD(TAG, "Couldn't send first MUTE packet to host");
|
|
reportTestResult(callerHandler, callerCallback, false);
|
|
quitHandlerThread(auxThread);
|
|
return;
|
|
}
|
|
|
|
// Sleep a while to make sure the previous command was executed
|
|
try {
|
|
Thread.sleep(2000);
|
|
} catch (InterruptedException exc) {
|
|
// Ignore
|
|
}
|
|
|
|
// Now get the new status and compare
|
|
action.execute(auxHostConnection, new ApiCallback<ApplicationType.PropertyValue>() {
|
|
@Override
|
|
public void onSuccess(ApplicationType.PropertyValue result) {
|
|
// Report result (mute status is different)
|
|
reportTestResult(callerHandler, callerCallback, initialMuteStatus != result.muted);
|
|
|
|
// Revert mute status
|
|
try {
|
|
mutePacket.send(hostInetAddress, hostInfo.getEventServerPort());
|
|
} catch (IOException exc) {
|
|
LogUtils.LOGD(TAG, "Couldn't revert MUTE status");
|
|
}
|
|
quitHandlerThread(auxThread);
|
|
}
|
|
|
|
@Override
|
|
public void onError(int errorCode, String description) {
|
|
LogUtils.LOGD(TAG, "Got an error on Application.GetProperties: " + description);
|
|
reportTestResult(callerHandler, callerCallback, false);
|
|
quitHandlerThread(auxThread);
|
|
}
|
|
}, auxHandler);
|
|
}
|
|
|
|
@Override
|
|
public void onError(int errorCode, String description) {
|
|
LogUtils.LOGD(TAG, "Got an error on Application.GetProperties: " + description);
|
|
reportTestResult(callerHandler, callerCallback, false);
|
|
quitHandlerThread(auxThread);
|
|
}
|
|
}, auxHandler);
|
|
}
|
|
});
|
|
|
|
}
|
|
|
|
private static void reportTestResult(final Handler callerHandler,
|
|
final EventServerConnectionCallback callback,
|
|
final boolean result) {
|
|
callerHandler.post(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
callback.OnConnectResult(result);
|
|
}
|
|
});
|
|
}
|
|
|
|
@SuppressLint("NewApi")
|
|
private static void quitHandlerThread(HandlerThread handlerThread) {
|
|
if (Utils.isJellybeanMR2OrLater()) {
|
|
handlerThread.quitSafely();
|
|
} else {
|
|
handlerThread.quit();
|
|
}
|
|
}
|
|
}
|