diff --git a/src/AndroidDesktop.cpp b/src/AndroidDesktop.cpp
index 72c5896..7539c69 100644
--- a/src/AndroidDesktop.cpp
+++ b/src/AndroidDesktop.cpp
@@ -141,8 +141,8 @@
     return rfb::Point(mPixels->width(), mPixels->height());
 }
 
-void AndroidDesktop::keyEvent(rdr::U32 key, bool down) {
-    mInputDevice->keyEvent(down, key);
+void AndroidDesktop::keyEvent(rdr::U32 keysym, __unused_attr rdr::U32 keycode, bool down) {
+    mInputDevice->keyEvent(down, keysym);
 }
 
 void AndroidDesktop::pointerEvent(const rfb::Point& pos, int buttonMask) {
@@ -190,3 +190,11 @@
     screens.add_screen(rfb::Screen(0, 0, 0, mPixels->width(), mPixels->height(), 0));
     mServer->setScreenLayout(screens);
 }
+
+void AndroidDesktop::queryConnection(network::Socket* sock, __unused_attr const char* userName) {
+    mServer->approveConnection(sock, true, NULL);
+}
+
+void AndroidDesktop::terminate() {
+    kill(getpid(), SIGTERM);
+}
