Refactor the framebuffer service

Change-Id: I8ac4580af65b8d58976c97b77b309dd202e75003

5 files changed, 749 insertions, 0 deletions

diff --git a/android/protocol/fb-updates-impl.c b/android/protocol/fb-updates-impl.c
new file mode 100644
index 0000000..ebe7309
--- /dev/null
+++ b/android/protocol/fb-updates-impl.c
@@ -0,0 +1,264 @@
+/* Copyright (C) 2010 The Android Open Source Project
+**
+** This software is licensed under the terms of the GNU General Public
+** License version 2, as published by the Free Software Foundation, and
+** may be copied, distributed, and modified under those terms.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+*/
+
+/*
+ * Contains UI-side framebuffer client that receives framebuffer updates
+ * from the core.
+ */
+
+#include "sysemu.h"
+#include "android/utils/system.h"
+#include "android/utils/debug.h"
+#include "android/utils/panic.h"
+#include "android/sync-utils.h"
+#include "android/protocol/fb-updates.h"
+#include "android/protocol/fb-updates-impl.h"
+
+/*Enumerates states for the client framebuffer update reader. */
+typedef enum ImplFBState {
+    /* The reader is waiting on update header. */
+    EXPECTS_HEADER,
+
+    /* The reader is waiting on pixels. */
+    EXPECTS_PIXELS,
+} ImplFBState;
+
+/* Descriptor for the UI-side implementation of the "framebufer" service.
+ */
+typedef struct ImplFramebuffer {
+    /* Framebuffer for this client. */
+    QFrameBuffer*   fb;
+
+    /* Core connection instance for the framebuffer client. */
+    CoreConnection* core_connection;
+
+    /* Current update header. */
+    FBUpdateMessage update_header;
+
+    /* Reader's buffer. */
+    uint8_t*        reader_buffer;
+
+    /* Offset in the reader's buffer where to read next chunk of data. */
+    size_t          reader_offset;
+
+    /* Total number of bytes the reader expects to read. */
+    size_t          reader_bytes;
+
+    /* Current state of the update reader. */
+    ImplFBState     fb_state;
+
+    /* Socket descriptor for the framebuffer client. */
+    int             sock;
+
+    /* Number of bits used to encode single pixel. */
+    int             bits_per_pixel;
+} ImplFramebuffer;
+
+/* One and the only ImplFramebuffer instance. */
+static ImplFramebuffer _implFb;
+
+/*
+ * Updates a display rectangle.
+ * Param
+ *  fb - Framebuffer where to update the rectangle.
+ *  x, y, w, and h define rectangle to update.
+ *  bits_per_pixel define number of bits used to encode a single pixel.
+ *  pixels contains pixels for the rectangle. Buffer addressed by this parameter
+ *      must be eventually freed with free()
+ */
+static void
+_update_rect(QFrameBuffer* fb, uint16_t x, uint16_t y, uint16_t w, uint16_t h,
+             uint8_t bits_per_pixel, uint8_t* pixels)
+{
+    if (fb != NULL) {
+        uint16_t n;
+        const uint8_t* src = pixels;
+        const uint16_t src_line_size = w * ((bits_per_pixel + 7) / 8);
+        uint8_t* dst  = (uint8_t*)fb->pixels + y * fb->pitch + x *
+                        fb->bytes_per_pixel;
+        for (n = 0; n < h; n++) {
+            memcpy(dst, src, src_line_size);
+            src += src_line_size;
+            dst += fb->pitch;
+        }
+        qframebuffer_update(fb, x, y, w, h);
+    }
+    free(pixels);
+}
+
+/*
+ * Asynchronous I/O callback launched when framebuffer notifications are ready
+ * to be read.
+ * Param:
+ *  opaque - ImplFramebuffer instance.
+ */
+static void
+_implFb_read_cb(void* opaque)
+{
+    ImplFramebuffer* fb_client = opaque;
+    int  ret;
+
+    // Read updates while they are immediately available.
+    for (;;) {
+        // Read next chunk of data.
+        ret = read(fb_client->sock, fb_client->reader_buffer + fb_client->reader_offset,
+                   fb_client->reader_bytes - fb_client->reader_offset);
+        if (ret == 0) {
+            /* disconnection ! */
+            implFb_destroy();
+            return;
+        }
+        if (ret < 0) {
+            if (errno == EINTR) {
+                /* loop on EINTR */
+                continue;
+            } else if (errno == EWOULDBLOCK || errno == EAGAIN) {
+                // Chunk is not avalable at this point. Come back later.
+                return;
+            }
+        }
+
+        fb_client->reader_offset += ret;
+        if (fb_client->reader_offset != fb_client->reader_bytes) {
+            // There are still some data left in the pipe.
+            continue;
+        }
+
+        // All expected data has been read. Time to change the state.
+        if (fb_client->fb_state == EXPECTS_HEADER) {
+            // Update header has been read. Prepare for the pixels.
+            fb_client->fb_state = EXPECTS_PIXELS;
+            fb_client->reader_offset = 0;
+            fb_client->reader_bytes = fb_client->update_header.w *
+                                      fb_client->update_header.h *
+                                      (fb_client->bits_per_pixel / 8);
+            fb_client->reader_buffer = malloc(fb_client->reader_bytes);
+            if (fb_client->reader_buffer == NULL) {
+                APANIC("Unable to allocate memory for framebuffer update\n");
+            }
+        } else {
+            // Pixels have been read. Prepare for the header.
+             uint8_t* pixels = fb_client->reader_buffer;
+
+            fb_client->fb_state = EXPECTS_HEADER;
+            fb_client->reader_offset = 0;
+            fb_client->reader_bytes = sizeof(FBUpdateMessage);
+            fb_client->reader_buffer = (uint8_t*)&fb_client->update_header;
+
+            // Perform the update. Note that pixels buffer must be freed there.
+            _update_rect(fb_client->fb, fb_client->update_header.x,
+                        fb_client->update_header.y, fb_client->update_header.w,
+                        fb_client->update_header.h, fb_client->bits_per_pixel,
+                        pixels);
+        }
+    }
+}
+
+int
+implFb_create(SockAddress* console_socket, const char* protocol, QFrameBuffer* fb)
+{
+    char* handshake = NULL;
+    char switch_cmd[256];
+
+    // Initialize descriptor.
+    _implFb.fb = fb;
+    _implFb.reader_buffer = (uint8_t*)&_implFb.update_header;
+    _implFb.reader_offset = 0;
+    _implFb.reader_bytes = sizeof(FBUpdateMessage);
+
+    // Connect to the framebuffer service.
+    snprintf(switch_cmd, sizeof(switch_cmd), "framebuffer %s", protocol);
+    _implFb.core_connection =
+        core_connection_create_and_switch(console_socket, switch_cmd, &handshake);
+    if (_implFb.core_connection == NULL) {
+        derror("Unable to connect to the framebuffer service: %s\n",
+               errno_str);
+        return -1;
+    }
+
+    // We expect core framebuffer to return us bits per pixel property in
+    // the handshake message.
+    _implFb.bits_per_pixel = 0;
+    if (handshake != NULL) {
+        char* bpp = strstr(handshake, "bitsperpixel=");
+        if (bpp != NULL) {
+            char* end;
+            bpp += strlen("bitsperpixel=");
+            end = strchr(bpp, ' ');
+            if (end == NULL) {
+                end = bpp + strlen(bpp);
+            }
+            _implFb.bits_per_pixel = strtol(bpp, &end, 0);
+        }
+    }
+    if (!_implFb.bits_per_pixel) {
+        derror("Unexpected core framebuffer reply: %s\n"
+               "Bits per pixel property is not there, or is invalid\n",
+               handshake);
+        implFb_destroy();
+        return -1;
+    }
+
+    _implFb.sock = core_connection_get_socket(_implFb.core_connection);
+
+    // At last setup read callback, and start receiving the updates.
+    if (qemu_set_fd_handler(_implFb.sock, _implFb_read_cb, NULL, &_implFb)) {
+        derror("Unable to set up framebuffer read callback.\n");
+        implFb_destroy();
+        return -1;
+    }
+    {
+        // Force the core to send us entire framebuffer now, when we're prepared
+        // to receive it.
+        FBRequestHeader hd;
+        SyncSocket* sk = syncsocket_init(_implFb.sock);
+
+        hd.request_type = AFB_REQUEST_REFRESH;
+        syncsocket_start_write(sk);
+        syncsocket_write(sk, &hd, sizeof(hd), 5000);
+        syncsocket_stop_write(sk);
+        syncsocket_free(sk);
+    }
+
+    fprintf(stdout, "framebuffer is now connected to the core at %s.",
+            sock_address_to_string(console_socket));
+    if (handshake != NULL) {
+        if (handshake[0] != '\0') {
+            fprintf(stdout, " Handshake: %s", handshake);
+        }
+        free(handshake);
+    }
+    fprintf(stdout, "\n");
+
+    return 0;
+}
+
+void
+implFb_destroy(void)
+{
+    if (_implFb.core_connection != NULL) {
+        // Disable the reader callback.
+        qemu_set_fd_handler(_implFb.sock, NULL, NULL, NULL);
+
+        // Close framebuffer connection.
+        core_connection_close(_implFb.core_connection);
+        core_connection_free(_implFb.core_connection);
+        _implFb.core_connection = NULL;
+    }
+
+    _implFb.fb = NULL;
+    if (_implFb.reader_buffer != NULL &&
+        _implFb.reader_buffer != (uint8_t*)&_implFb.update_header) {
+        free(_implFb.reader_buffer);
+        _implFb.reader_buffer = (uint8_t*)&_implFb.update_header;
+    }
+}
diff --git a/android/protocol/fb-updates-impl.h b/android/protocol/fb-updates-impl.h
new file mode 100644
index 0000000..0c351aa
--- /dev/null
+++ b/android/protocol/fb-updates-impl.h
@@ -0,0 +1,44 @@
+/* Copyright (C) 2010 The Android Open Source Project
+**
+** This software is licensed under the terms of the GNU General Public
+** License version 2, as published by the Free Software Foundation, and
+** may be copied, distributed, and modified under those terms.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+*/
+
+/*
+ * Contains UI-side "framebuffer" client that receives framebuffer updates
+ * from the Core.
+ */
+
+#ifndef _ANDROID_FRAMEBUFFER_UI_H
+#define _ANDROID_FRAMEBUFFER_UI_H
+
+#include "console.h"
+#include "framebuffer.h"
+#include "android/looper.h"
+#include "android/async-utils.h"
+#include "android/core-connection.h"
+
+/* Creates framebuffer client, and connects it with the core.
+ * Param:
+ *  console_socket Address of the core's console socket.
+ *  protocol Protocol to use for the updates:
+ *      -raw Stream pixels over socket
+ *      -shared Use shared memory for pixels.
+ * fb - Framebuffer associated with this FB client.
+ * Return:
+ *  0 on success, or < 0 on failure.
+ */
+int implFb_create(SockAddress* console_socket,
+                  const char* protocol,
+                  QFrameBuffer* fb);
+
+/* Disconnects and destroys framebuffer client. */
+void implFb_destroy(void);
+
+#endif /* _ANDROID_FRAMEBUFFER_UI_H */
diff --git a/android/protocol/fb-updates-proxy.c b/android/protocol/fb-updates-proxy.c
new file mode 100644
index 0000000..fee1195
--- /dev/null
+++ b/android/protocol/fb-updates-proxy.c
@@ -0,0 +1,332 @@
+/* Copyright (C) 2010 The Android Open Source Project
+**
+** This software is licensed under the terms of the GNU General Public
+** License version 2, as published by the Free Software Foundation, and
+** may be copied, distributed, and modified under those terms.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+*/
+
+/*
+ * Contains core-side framebuffer service that sends framebuffer updates
+ * to the UI connected to the core.
+ */
+
+#include "console.h"
+#include "framebuffer.h"
+#include "android/looper.h"
+#include "android/display-core.h"
+#include "android/async-utils.h"
+#include "android/protocol/fb-updates.h"
+#include "android/protocol/fb-updates-proxy.h"
+#include "android/utils/system.h"
+#include "android/utils/debug.h"
+
+/* Descriptor for the Core-side implementation of the "framebufer" service.
+ */
+struct ProxyFramebuffer {
+    /* Writer used to send FB update notification messages. */
+    AsyncWriter             fb_update_writer;
+
+    /* Reader used to read FB requests from the client. */
+    AsyncReader             fb_req_reader;
+
+    /* I/O associated with this descriptor. */
+    LoopIo                  io;
+
+    /* Framebuffer used for this service. */
+    QFrameBuffer*           fb;
+
+    /* Looper used to communicate framebuffer updates. */
+    Looper* looper;
+
+    /* Head of the list of pending FB update notifications. */
+    struct FBUpdateNotify*  fb_update_head;
+
+    /* Tail of the list of pending FB update notifications. */
+    struct FBUpdateNotify*  fb_update_tail;
+
+    /* Socket used to communicate framebuffer updates. */
+    int     sock;
+
+    /* Framebuffer request header. */
+    FBRequestHeader         fb_req_header;
+};
+
+/* Framebuffer update notification descriptor. */
+typedef struct FBUpdateNotify {
+    /* Links all pending FB update notifications. */
+    struct FBUpdateNotify*  next_fb_update;
+
+    /* Core framebuffer instance that owns the message. */
+    ProxyFramebuffer*       proxy_fb;
+
+    /* Size of the message to transfer. */
+    size_t                  message_size;
+
+    /* Update message. */
+    FBUpdateMessage         message;
+} FBUpdateNotify;
+
+/*
+ * Gets pointer in framebuffer's pixels for the given pixel.
+ * Param:
+ *  fb Framebuffer containing pixels.
+ *  x, and y identify the pixel to get pointer for.
+ * Return:
+ *  Pointer in framebuffer's pixels for the given pixel.
+ */
+static const uint8_t*
+_pixel_offset(const QFrameBuffer* fb, int x, int y)
+{
+    return (const uint8_t*)fb->pixels + y * fb->pitch + x * fb->bytes_per_pixel;
+}
+
+/*
+ * Copies pixels from a framebuffer rectangle.
+ * Param:
+ *  rect - Buffer where to copy pixel.
+ *  fb - Framebuffer containing the rectangle to copy.
+ *  x, y, w, and h - dimensions of the rectangle to copy.
+ */
+static void
+_copy_fb_rect(uint8_t* rect, const QFrameBuffer* fb, int x, int y, int w, int h)
+{
+    const uint8_t* start = _pixel_offset(fb, x, y);
+    for (; h > 0; h--) {
+        memcpy(rect, start, w * fb->bytes_per_pixel);
+        start += fb->pitch;
+        rect += w * fb->bytes_per_pixel;
+    }
+}
+
+/*
+ * Allocates and initializes framebuffer update notification descriptor.
+ * Param:
+ *  ds - Display state for the framebuffer.
+ *  fb Framebuffer containing pixels.
+ *  x, y, w, and h identify the rectangle that is being updated.
+ * Return:
+ *  Initialized framebuffer update notification descriptor.
+ */
+static FBUpdateNotify*
+fbupdatenotify_create(ProxyFramebuffer* proxy_fb, const QFrameBuffer* fb,
+                      int x, int y, int w, int h)
+{
+    const size_t rect_size = w * h * fb->bytes_per_pixel;
+    FBUpdateNotify* ret = malloc(sizeof(FBUpdateNotify) + rect_size);
+
+    ret->next_fb_update = NULL;
+    ret->proxy_fb = proxy_fb;
+    ret->message_size = sizeof(FBUpdateMessage) + rect_size;
+    ret->message.x = x;
+    ret->message.y = y;
+    ret->message.w = w;
+    ret->message.h = h;
+    _copy_fb_rect(ret->message.rect, fb, x, y, w, h);
+    return ret;
+}
+
+/*
+ * Deletes FBUpdateNotify descriptor, created with fbupdatenotify_create.
+ * Param:
+ *  desc - Descreptor to delete.
+ */
+static void
+fbupdatenotify_delete(FBUpdateNotify* desc)
+{
+    if (desc != NULL) {
+        free(desc);
+    }
+}
+
+/* Implemented in android/console.c */
+extern void destroy_control_fb_client(void);
+
+/*
+ * Asynchronous write I/O callback launched when writing framebuffer
+ * notifications to the socket.
+ * Param:
+ *  proxy_fb - ProxyFramebuffer instance.
+ */
+static void
+_proxyFb_io_write(ProxyFramebuffer* proxy_fb)
+{
+    while (proxy_fb->fb_update_head != NULL) {
+        FBUpdateNotify* current_update = proxy_fb->fb_update_head;
+        // Lets continue writing of the current notification.
+        const AsyncStatus status =
+            asyncWriter_write(&proxy_fb->fb_update_writer, &proxy_fb->io);
+        switch (status) {
+            case ASYNC_COMPLETE:
+                // Done with the current update. Move on to the next one.
+                break;
+            case ASYNC_ERROR:
+                // Done with the current update. Move on to the next one.
+                loopIo_dontWantWrite(&proxy_fb->io);
+                break;
+
+            case ASYNC_NEED_MORE:
+                // Transfer will eventually come back into this routine.
+                return;
+        }
+
+        // Advance the list of updates
+        proxy_fb->fb_update_head = current_update->next_fb_update;
+        if (proxy_fb->fb_update_head == NULL) {
+            proxy_fb->fb_update_tail = NULL;
+        }
+        fbupdatenotify_delete(current_update);
+
+        if (proxy_fb->fb_update_head != NULL) {
+            // Schedule the next one.
+            asyncWriter_init(&proxy_fb->fb_update_writer,
+                             &proxy_fb->fb_update_head->message,
+                             proxy_fb->fb_update_head->message_size,
+                             &proxy_fb->io);
+        }
+    }
+}
+
+/*
+ * Asynchronous read I/O callback launched when reading framebuffer requests
+ * from the socket.
+ * Param:
+ *  proxy_fb - ProxyFramebuffer instance.
+ */
+static void
+_proxyFb_io_read(ProxyFramebuffer* proxy_fb)
+{
+    // Read the request header.
+    const AsyncStatus status =
+        asyncReader_read(&proxy_fb->fb_req_reader, &proxy_fb->io);
+    switch (status) {
+        case ASYNC_COMPLETE:
+            // Request header is received
+            switch (proxy_fb->fb_req_header.request_type) {
+                case AFB_REQUEST_REFRESH:
+                    // Force full screen update to be sent
+                    proxyFb_update(proxy_fb, proxy_fb->fb,
+                                  0, 0, proxy_fb->fb->width,
+                                  proxy_fb->fb->height);
+                    break;
+                default:
+                    derror("Unknown framebuffer request %d\n",
+                           proxy_fb->fb_req_header.request_type);
+                    break;
+            }
+            proxy_fb->fb_req_header.request_type = -1;
+            asyncReader_init(&proxy_fb->fb_req_reader, &proxy_fb->fb_req_header,
+                             sizeof(proxy_fb->fb_req_header), &proxy_fb->io);
+            break;
+        case ASYNC_ERROR:
+            loopIo_dontWantRead(&proxy_fb->io);
+            if (errno == ECONNRESET) {
+                // UI has exited. We need to destroy framebuffer service.
+                destroy_control_fb_client();
+            }
+            break;
+
+        case ASYNC_NEED_MORE:
+            // Transfer will eventually come back into this routine.
+            return;
+    }
+}
+
+/*
+ * Asynchronous I/O callback launched when writing framebuffer notifications
+ * to the socket.
+ * Param:
+ *  opaque - ProxyFramebuffer instance.
+ */
+static void
+_proxyFb_io_fun(void* opaque, int fd, unsigned events)
+{
+    if (events & LOOP_IO_READ) {
+        _proxyFb_io_read((ProxyFramebuffer*)opaque);
+    } else if (events & LOOP_IO_WRITE) {
+        _proxyFb_io_write((ProxyFramebuffer*)opaque);
+    }
+}
+
+ProxyFramebuffer*
+proxyFb_create(int sock, const char* protocol, QFrameBuffer* fb)
+{
+    // At this point we're implementing the -raw protocol only.
+    ProxyFramebuffer* ret;
+    ANEW0(ret);
+    ret->sock = sock;
+    ret->looper = looper_newCore();
+    ret->fb = fb;
+    ret->fb_update_head = NULL;
+    ret->fb_update_tail = NULL;
+    loopIo_init(&ret->io, ret->looper, sock, _proxyFb_io_fun, ret);
+    asyncReader_init(&ret->fb_req_reader, &ret->fb_req_header,
+                     sizeof(ret->fb_req_header), &ret->io);
+    return ret;
+}
+
+void
+proxyFb_destroy(ProxyFramebuffer* proxy_fb)
+{
+    if (proxy_fb != NULL) {
+        if (proxy_fb->looper != NULL) {
+            // Stop all I/O that may still be going on.
+            loopIo_done(&proxy_fb->io);
+            // Delete all pending frame updates.
+            while (proxy_fb->fb_update_head != NULL) {
+                FBUpdateNotify* pending_update = proxy_fb->fb_update_head;
+                proxy_fb->fb_update_head = pending_update->next_fb_update;
+                fbupdatenotify_delete(pending_update);
+            }
+            proxy_fb->fb_update_tail = NULL;
+            looper_free(proxy_fb->looper);
+            proxy_fb->looper = NULL;
+        }
+    }
+}
+
+void
+proxyFb_update(ProxyFramebuffer* proxy_fb,
+              struct QFrameBuffer* fb, int x, int y, int w, int h)
+{
+    AsyncStatus status;
+    FBUpdateNotify* descr = fbupdatenotify_create(proxy_fb, fb, x, y, w, h);
+
+    // Lets see if we should list it behind other pending updates.
+    if (proxy_fb->fb_update_tail != NULL) {
+        proxy_fb->fb_update_tail->next_fb_update = descr;
+        proxy_fb->fb_update_tail = descr;
+        return;
+    }
+
+    // We're first in the list. Just send it now.
+    proxy_fb->fb_update_head = proxy_fb->fb_update_tail = descr;
+    asyncWriter_init(&proxy_fb->fb_update_writer,
+                     &proxy_fb->fb_update_head->message,
+                     proxy_fb->fb_update_head->message_size, &proxy_fb->io);
+    status = asyncWriter_write(&proxy_fb->fb_update_writer, &proxy_fb->io);
+    switch (status) {
+        case ASYNC_COMPLETE:
+            fbupdatenotify_delete(descr);
+            proxy_fb->fb_update_head = proxy_fb->fb_update_tail = NULL;
+            return;
+        case ASYNC_ERROR:
+            fbupdatenotify_delete(descr);
+            proxy_fb->fb_update_head = proxy_fb->fb_update_tail = NULL;
+            return;
+        case ASYNC_NEED_MORE:
+            // Update transfer will eventually complete in _proxyFb_io_fun
+            return;
+    }
+}
+
+int
+proxyFb_get_bits_per_pixel(ProxyFramebuffer* proxy_fb)
+{
+    return (proxy_fb != NULL && proxy_fb->fb != NULL) ?
+                                            proxy_fb->fb->bits_per_pixel : -1;
+}
diff --git a/android/protocol/fb-updates-proxy.h b/android/protocol/fb-updates-proxy.h
new file mode 100644
index 0000000..e750f1a
--- /dev/null
+++ b/android/protocol/fb-updates-proxy.h
@@ -0,0 +1,64 @@
+/* Copyright (C) 2010 The Android Open Source Project
+**
+** This software is licensed under the terms of the GNU General Public
+** License version 2, as published by the Free Software Foundation, and
+** may be copied, distributed, and modified under those terms.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+*/
+
+/*
+ * Contains core-side framebuffer service that sends framebuffer updates
+ * to the UI connected to the core.
+ */
+
+#ifndef _ANDROID_PROTOCOL_FB_UPDATES_PROXY_H
+#define _ANDROID_PROTOCOL_FB_UPDATES_PROXY_H
+
+/* Descriptor for a framebuffer core service instance */
+typedef struct ProxyFramebuffer ProxyFramebuffer;
+
+/*
+ * Creates framebuffer service.
+ * Param:
+ *  sock - Socket descriptor for the service
+ *  protocol - Defines protocol to use when sending FB updates to the UI. The
+ *      supported values ar:
+ *      -raw Transfers the updating rectangle buffer over the socket.
+ *      -shared Used a shared memory to transfer the updating rectangle buffer.
+ *  fb - Framebuffer descriptor for this service.
+ * Return:
+ *  Framebuffer service descriptor.
+ */
+ProxyFramebuffer* proxyFb_create(int sock, const char* protocol, struct QFrameBuffer* fb);
+
+/*
+ * Destroys framebuffer service created with proxyFb_create.
+ * Param:
+ *  core_fb - Framebuffer service descriptor created with proxyFb_create
+ */
+void proxyFb_destroy(ProxyFramebuffer* core_fb);
+
+/*
+ * Notifies framebuffer client about changes in framebuffer.
+ * Param:
+ *  core_fb - Framebuffer service descriptor created with proxyFb_create
+ *  fb Framebuffer containing pixels.
+ *  x, y, w, and h identify the rectangle that has benn changed.
+ */
+void proxyFb_update(ProxyFramebuffer* core_fb, struct QFrameBuffer* fb,
+                   int x, int y, int w, int h);
+
+/*
+ * Gets number of bits used to encode a single pixel.
+ * Param:
+ *  core_fb - Framebuffer service descriptor created with proxyFb_create
+ * Return:
+ *  Number of bits used to encode a single pixel.
+ */
+int proxyFb_get_bits_per_pixel(ProxyFramebuffer* core_fb);
+
+#endif /* _ANDROID_PROTOCOL_FB_UPDATES_PROXY_H */
diff --git a/android/protocol/fb-updates.h b/android/protocol/fb-updates.h
new file mode 100644
index 0000000..c4f9779
--- /dev/null
+++ b/android/protocol/fb-updates.h
@@ -0,0 +1,45 @@
+/* Copyright (C) 2010 The Android Open Source Project
+**
+** This software is licensed under the terms of the GNU General Public
+** License version 2, as published by the Free Software Foundation, and
+** may be copied, distributed, and modified under those terms.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+*/
+
+/*
+ * Contains the API for calling into the UI with Core's framebuffer updates.
+ */
+
+#ifndef _ANDROID_PROTOCOL_FB_UPDATES_H
+#define _ANDROID_PROTOCOL_FB_UPDATES_H
+
+#include "sysemu.h"
+
+/* Requests the Core to refresh framebuffer.
+ * This message is sent by the UI to the Core right after the UI is initialized.
+ * This message forces the Core to send a full display update back to the UI. */
+#define AFB_REQUEST_REFRESH     1
+
+/* Header of framebuffer update message sent from the core to the UI. */
+typedef struct FBUpdateMessage {
+    /* x, y, w, and h identify the rectangle that is being updated. */
+    uint16_t    x;
+    uint16_t    y;
+    uint16_t    w;
+    uint16_t    h;
+
+    /* Contains updating rectangle copied over from the framebuffer's pixels. */
+    uint8_t rect[0];
+} FBUpdateMessage;
+
+/* Header for framebuffer requests sent from the UI to the Core. */
+typedef struct FBRequestHeader {
+    /* Request type. See AFB_REQUEST_XXX for the values. */
+    uint8_t request_type;
+} FBRequestHeader;
+
+#endif /* _ANDROID_PROTOCOL_FB_UPDATES_H */