Merge lp:~kdub/mir/android-display-factory into lp:~mir-team/mir/trunk

[Kevin DuBois]

change construction of android output so that the best available output path can be used

change construction of android output so that the best available output path can be used

Android has different output paths. Mir is using the fallback gpu output path at the moment. Most android devices use their HWC module as the output path and fall back to the GPU mode if the hwc is not available. This change detects the output paths available on the device at mg::Display construction and allocs the best display type.

Specifically, this change detects if we have HWC 1.1 (the version that the nexus 4 uses) available, and constructs using a different function if it is. If it is not, it constructs the gpu display.

I anticipate we'll have to eventually support gpu (the fallback), hwc 1.0 (galaxy nexus), 1.1 (nexus4) and 1.2 (most recent hwc version). These versions have some commonality, but the versions were undergoing sufficiently rapid changes that we should construct different HWC objects for the different versions.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:510
http://jenkins.qa.ubuntu.com/job/mir-ci/119/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/19/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/120/console

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/mir-ci/119/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:513
http://jenkins.qa.ubuntu.com/job/mir-ci/122/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/24/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/123/console
        deb: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/123/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/mir-ci/122/rebuild

review: Approve (continuous-integration)

[Kevin DuBois (kdub)]

also, there are 2 files (hwcomposer_deps.h and hwcomposer_v0.h) that have been added from the android hardware libraries, which are needed, but were left out when I add hwcomposer.h

[Alan Griffiths (alan-griffiths)]

504 - mc::Compositor compositor{surface_stack,gl_renderer};
505 + mc::DefaultCompositingStrategy compositing_strategy{surface_stack,gl_renderer};

This reminds me we should rewrite render_surfaces to use DefaultServerConfiguration to configure things, rather than code the knowledge here too.

[Alan Griffiths (alan-griffiths)]

Hmm, there are a lot of lines in the web diff that don't belong. I guess a missing pre-req has landed.

[Alan Griffiths (alan-griffiths)]

1402 + if (display_type == mga::DisplayType::HWC_1_1)
1403 + {
1404 + return fb_factory->create_hwc1_1_gpu_display();
1405 + } else {
1406 + return fb_factory->create_gpu_display();
1407 + }

I'm not sure why we need DisplayType to support this use.

Polymorphism (or a function pointer) would seem more natural.

Anyway "} else {" appears a few times and isn't our style.

review: Needs Fixing

[Kevin DuBois (kdub)]

> 1402 + if (display_type == mga::DisplayType::HWC_1_1)
> 1403 + {
> 1404 + return fb_factory->create_hwc1_1_gpu_display();
> 1405 + } else {
> 1406 + return fb_factory->create_gpu_display();
> 1407 + }
>
> I'm not sure why we need DisplayType to support this use.
>

good point, i'll rework

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:515
http://jenkins.qa.ubuntu.com/job/mir-ci/170/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/91
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/171
        deb: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/171/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins:8080/job/mir-ci/170/rebuild

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

741 + std::function<std::shared_ptr<Display>()> allocate_primary_fb;

This could be a simple pointer to member function. Vis:

typedef std::shared_ptr<Display>() (FBFactory::*AllocatePrimaryFb)();
AllocatePrimaryFb allocate_primary_fb;

[Alan Griffiths (alan-griffiths)]

review: Approve

[Alexandros Frantzis (afrantzis)]

1083 -class AndroidBufferAllocatorTest : public ::testing::Test
1084 +struct AndroidBufferAllocatorTest : public ::testing::Test
1085 {
1086 + testing::NiceMock<mt::HardwareAccessMock> hw_access_mock;
1087 public:

Remove "public" (since this is now a struct)?

1232 +set(C_MOCKS_SOURCES

What does the C in C_MOCKS_SOURCES mean. C code?

663 + : fb_factory(factory)
1281 + : mock_hw_device(device)
... and other places

There are inconsistencies in the way the constructor lists are indented. Our guidelines say 4 spaces.

675 + hw_device_t* hwc_device;
676 + hw_module->methods->open(hw_module, HWC_HARDWARE_COMPOSER, &hwc_device);
678 + if (hwc_device->version == HWC_DEVICE_API_VERSION_1_1)

Shouldn't we be checking if the operation succeeds before using the hwc_device pointer?

975 + virtual ~FBFactory() {};

-;

1332 + ADD_FAILURE_AT(__FILE__,__LINE__);

An assertion would probably be a better choice here, or is there a test case in which we need to continue regardless of the error?

review: Needs Fixing

[Kevin DuBois (kdub)]

should have addressed the concerns, except
> 1332 + ADD_FAILURE_AT(__FILE__,__LINE__);
>
> An assertion would probably be a better choice here, or is there a test case
> in which we need to continue regardless of the error?

gtest's ASSERT_ macros didn't work here, I think thats why we did this way with the egl/gl mocks as well

[Kevin DuBois (kdub)]

> 1232 +set(C_MOCKS_SOURCES
>
> What does the C in C_MOCKS_SOURCES mean. C code?
that was the idea, but i changed it to be consistent with the name of the library

[Alexandros Frantzis (afrantzis)]

Looks good.

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:518
http://jenkins.qa.ubuntu.com/job/mir-ci/181/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/106
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/182
        deb: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/182/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins:8080/job/mir-ci/181/rebuild

review: Approve (continuous-integration)

=== added file '3rd_party/android-deps/hardware/hwcomposer_defs.h'
--- 3rd_party/android-deps/hardware/hwcomposer_defs.h	1970-01-01 00:00:00 +0000
+++ 3rd_party/android-deps/hardware/hwcomposer_defs.h	2013-03-22 15:42:23 +0000
@@ -0,0 +1,205 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#ifndef ANDROID_INCLUDE_HARDWARE_HWCOMPOSER_DEFS_H
+#define ANDROID_INCLUDE_HARDWARE_HWCOMPOSER_DEFS_H
+
+#include <stdint.h>
+#include <sys/cdefs.h>
+
+#include <hardware/gralloc.h>
+#include <hardware/hardware.h>
+#include <cutils/native_handle.h>
+
+__BEGIN_DECLS
+
+/*****************************************************************************/
+
+#define HWC_HEADER_VERSION          1
+
+#define HWC_MODULE_API_VERSION_0_1  HARDWARE_MODULE_API_VERSION(0, 1)
+
+#define HWC_DEVICE_API_VERSION_0_1  HARDWARE_DEVICE_API_VERSION_2(0, 1, HWC_HEADER_VERSION)
+#define HWC_DEVICE_API_VERSION_0_2  HARDWARE_DEVICE_API_VERSION_2(0, 2, HWC_HEADER_VERSION)
+#define HWC_DEVICE_API_VERSION_0_3  HARDWARE_DEVICE_API_VERSION_2(0, 3, HWC_HEADER_VERSION)
+#define HWC_DEVICE_API_VERSION_1_0  HARDWARE_DEVICE_API_VERSION_2(1, 0, HWC_HEADER_VERSION)
+#define HWC_DEVICE_API_VERSION_1_1  HARDWARE_DEVICE_API_VERSION_2(1, 1, HWC_HEADER_VERSION)
+#define HWC_DEVICE_API_VERSION_1_2  HARDWARE_DEVICE_API_VERSION_2(1, 2, HWC_HEADER_VERSION)
+
+enum {
+    /* hwc_composer_device_t::set failed in EGL */
+    HWC_EGL_ERROR = -1
+};
+
+/*
+ * hwc_layer_t::hints values
+ * Hints are set by the HAL and read by SurfaceFlinger
+ */
+enum {
+    /*
+     * HWC can set the HWC_HINT_TRIPLE_BUFFER hint to indicate to SurfaceFlinger
+     * that it should triple buffer this layer. Typically HWC does this when
+     * the layer will be unavailable for use for an extended period of time,
+     * e.g. if the display will be fetching data directly from the layer and
+     * the layer can not be modified until after the next set().
+     */
+    HWC_HINT_TRIPLE_BUFFER  = 0x00000001,
+
+    /*
+     * HWC sets HWC_HINT_CLEAR_FB to tell SurfaceFlinger that it should clear the
+     * framebuffer with transparent pixels where this layer would be.
+     * SurfaceFlinger will only honor this flag when the layer has no blending
+     *
+     */
+    HWC_HINT_CLEAR_FB       = 0x00000002
+};
+
+/*
+ * hwc_layer_t::flags values
+ * Flags are set by SurfaceFlinger and read by the HAL
+ */
+enum {
+    /*
+     * HWC_SKIP_LAYER is set by SurfaceFlnger to indicate that the HAL
+     * shall not consider this layer for composition as it will be handled
+     * by SurfaceFlinger (just as if compositionType was set to HWC_OVERLAY).
+     */
+    HWC_SKIP_LAYER = 0x00000001,
+};
+
+/*
+ * hwc_layer_t::compositionType values
+ */
+enum {
+    /* this layer is to be drawn into the framebuffer by SurfaceFlinger */
+    HWC_FRAMEBUFFER = 0,
+
+    /* this layer will be handled in the HWC */
+    HWC_OVERLAY = 1,
+
+    /* this is the background layer. it's used to set the background color.
+     * there is only a single background layer */
+    HWC_BACKGROUND = 2,
+
+    /* this layer holds the result of compositing the HWC_FRAMEBUFFER layers.
+     * Added in HWC_DEVICE_API_VERSION_1_1. */
+    HWC_FRAMEBUFFER_TARGET = 3,
+
+    /* this layer will be handled in the HWC, using a blit engine */
+    HWC_BLIT = 4,
+};
+
+/*
+ * hwc_layer_t::blending values
+ */
+enum {
+    /* no blending */
+    HWC_BLENDING_NONE     = 0x0100,
+
+    /* ONE / ONE_MINUS_SRC_ALPHA */
+    HWC_BLENDING_PREMULT  = 0x0105,
+
+    /* SRC_ALPHA / ONE_MINUS_SRC_ALPHA */
+    HWC_BLENDING_COVERAGE = 0x0405
+};
+
+/*
+ * hwc_layer_t::transform values
+ */
+enum {
+    /* flip source image horizontally */
+    HWC_TRANSFORM_FLIP_H = HAL_TRANSFORM_FLIP_H,
+    /* flip source image vertically */
+    HWC_TRANSFORM_FLIP_V = HAL_TRANSFORM_FLIP_V,
+    /* rotate source image 90 degrees clock-wise */
+    HWC_TRANSFORM_ROT_90 = HAL_TRANSFORM_ROT_90,
+    /* rotate source image 180 degrees */
+    HWC_TRANSFORM_ROT_180 = HAL_TRANSFORM_ROT_180,
+    /* rotate source image 270 degrees clock-wise */
+    HWC_TRANSFORM_ROT_270 = HAL_TRANSFORM_ROT_270,
+};
+
+/* attributes queriable with query() */
+enum {
+    /*
+     * Availability: HWC_DEVICE_API_VERSION_0_2
+     * Must return 1 if the background layer is supported, 0 otherwise.
+     */
+    HWC_BACKGROUND_LAYER_SUPPORTED      = 0,
+
+    /*
+     * Availability: HWC_DEVICE_API_VERSION_0_3
+     * Returns the vsync period in nanoseconds.
+     *
+     * This query is not used for HWC_DEVICE_API_VERSION_1_1 and later.
+     * Instead, the per-display attribute HWC_DISPLAY_VSYNC_PERIOD is used.
+     */
+    HWC_VSYNC_PERIOD                    = 1,
+
+    /*
+     * Availability: HWC_DEVICE_API_VERSION_1_1
+     * Returns a mask of supported display types.
+     */
+    HWC_DISPLAY_TYPES_SUPPORTED         = 2,
+};
+
+/* display attributes returned by getDisplayAttributes() */
+enum {
+    /* Indicates the end of an attribute list */
+    HWC_DISPLAY_NO_ATTRIBUTE                = 0,
+
+    /* The vsync period in nanoseconds */
+    HWC_DISPLAY_VSYNC_PERIOD                = 1,
+
+    /* The number of pixels in the horizontal and vertical directions. */
+    HWC_DISPLAY_WIDTH                       = 2,
+    HWC_DISPLAY_HEIGHT                      = 3,
+
+    /* The number of pixels per thousand inches of this configuration.
+     *
+     * Scaling DPI by 1000 allows it to be stored in an int without losing
+     * too much precision.
+     *
+     * If the DPI for a configuration is unavailable or the HWC implementation
+     * considers it unreliable, it should set these attributes to zero.
+     */
+    HWC_DISPLAY_DPI_X                       = 4,
+    HWC_DISPLAY_DPI_Y                       = 5,
+};
+
+/* Allowed events for hwc_methods::eventControl() */
+enum {
+    HWC_EVENT_VSYNC     = 0,
+    HWC_EVENT_ORIENTATION    // To notify HWC about the device orientation
+};
+
+/* Display types and associated mask bits. */
+enum {
+    HWC_DISPLAY_PRIMARY     = 0,
+    HWC_DISPLAY_EXTERNAL    = 1,    // HDMI, DP, etc.
+    HWC_NUM_DISPLAY_TYPES
+};
+
+enum {
+    HWC_DISPLAY_PRIMARY_BIT     = 1 << HWC_DISPLAY_PRIMARY,
+    HWC_DISPLAY_EXTERNAL_BIT    = 1 << HWC_DISPLAY_EXTERNAL,
+};
+
+/*****************************************************************************/
+
+__END_DECLS
+
+#endif /* ANDROID_INCLUDE_HARDWARE_HWCOMPOSER_DEFS_H */

=== added file '3rd_party/android-deps/hardware/hwcomposer_v0.h'
--- 3rd_party/android-deps/hardware/hwcomposer_v0.h	1970-01-01 00:00:00 +0000
+++ 3rd_party/android-deps/hardware/hwcomposer_v0.h	2013-03-22 15:42:23 +0000
@@ -0,0 +1,272 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * 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.
+ */
+
+/* This header contains deprecated HWCv0 interface declarations. Don't include
+ * this header directly; it will be included by <hardware/hwcomposer.h> unless
+ * HWC_REMOVE_DEPRECATED_VERSIONS is defined to non-zero.
+ */
+#ifndef ANDROID_INCLUDE_HARDWARE_HWCOMPOSER_H
+#error "This header should only be included by hardware/hwcomposer.h"
+#endif
+
+#ifndef ANDROID_INCLUDE_HARDWARE_HWCOMPOSER_V0_H
+#define ANDROID_INCLUDE_HARDWARE_HWCOMPOSER_V0_H
+
+struct hwc_composer_device;
+
+/*
+ * availability: HWC_DEVICE_API_VERSION_0_3
+ *
+ * struct hwc_methods cannot be embedded in other structures as
+ * sizeof(struct hwc_methods) cannot be relied upon.
+ *
+ */
+typedef struct hwc_methods {
+
+    /*************************************************************************
+     * HWC_DEVICE_API_VERSION_0_3
+     *************************************************************************/
+
+    /*
+     * eventControl(..., event, enabled)
+     * Enables or disables h/w composer events.
+     *
+     * eventControl can be called from any thread and takes effect
+     * immediately.
+     *
+     *  Supported events are:
+     *      HWC_EVENT_VSYNC
+     *
+     * returns -EINVAL if the "event" parameter is not one of the value above
+     * or if the "enabled" parameter is not 0 or 1.
+     */
+
+    int (*eventControl)(
+            struct hwc_composer_device* dev, int event, int enabled);
+
+} hwc_methods_t;
+
+typedef struct hwc_layer {
+    /*
+     * initially set to HWC_FRAMEBUFFER or HWC_BACKGROUND.
+     * HWC_FRAMEBUFFER
+     *   indicates the layer will be drawn into the framebuffer
+     *   using OpenGL ES.
+     *   The HWC can toggle this value to HWC_OVERLAY, to indicate
+     *   it will handle the layer.
+     *
+     * HWC_BACKGROUND
+     *   indicates this is a special "background"  layer. The only valid
+     *   field is backgroundColor. HWC_BACKGROUND can only be used with
+     *   HWC_API_VERSION >= 0.2
+     *   The HWC can toggle this value to HWC_FRAMEBUFFER, to indicate
+     *   it CANNOT handle the background color
+     *
+     */
+    int32_t compositionType;
+
+    /* see hwc_layer_t::hints above */
+    uint32_t hints;
+
+    /* see hwc_layer_t::flags above */
+    uint32_t flags;
+
+    union {
+        /* color of the background.  hwc_color_t.a is ignored */
+        hwc_color_t backgroundColor;
+
+        struct {
+            /* handle of buffer to compose. This handle is guaranteed to have been
+             * allocated from gralloc using the GRALLOC_USAGE_HW_COMPOSER usage flag. If
+             * the layer's handle is unchanged across two consecutive prepare calls and
+             * the HWC_GEOMETRY_CHANGED flag is not set for the second call then the
+             * HWComposer implementation may assume that the contents of the buffer have
+             * not changed. */
+            buffer_handle_t handle;
+
+            /* transformation to apply to the buffer during composition */
+            uint32_t transform;
+
+            /* blending to apply during composition */
+            int32_t blending;
+
+            /* area of the source to consider, the origin is the top-left corner of
+             * the buffer */
+            hwc_rect_t sourceCrop;
+
+            /* where to composite the sourceCrop onto the display. The sourceCrop
+             * is scaled using linear filtering to the displayFrame. The origin is the
+             * top-left corner of the screen.
+             */
+            hwc_rect_t displayFrame;
+
+            /* visible region in screen space. The origin is the
+             * top-left corner of the screen.
+             * The visible region INCLUDES areas overlapped by a translucent layer.
+             */
+            hwc_region_t visibleRegionScreen;
+        };
+    };
+} hwc_layer_t;
+
+/*
+ * List of layers.
+ * The handle members of hwLayers elements must be unique.
+ */
+typedef struct hwc_layer_list {
+    uint32_t flags;
+    size_t numHwLayers;
+    hwc_layer_t hwLayers[0];
+} hwc_layer_list_t;
+
+/*****************************************************************************/
+
+typedef struct hwc_composer_device {
+    struct hw_device_t common;
+
+    /*
+     * (*prepare)() is called for each frame before composition and is used by
+     * SurfaceFlinger to determine what composition steps the HWC can handle.
+     *
+     * (*prepare)() can be called more than once, the last call prevails.
+     *
+     * The HWC responds by setting the compositionType field to either
+     * HWC_FRAMEBUFFER or HWC_OVERLAY. In the former case, the composition for
+     * this layer is handled by SurfaceFlinger with OpenGL ES, in the later
+     * case, the HWC will have to handle this layer's composition.
+     *
+     * (*prepare)() is called with HWC_GEOMETRY_CHANGED to indicate that the
+     * list's geometry has changed, that is, when more than just the buffer's
+     * handles have been updated. Typically this happens (but is not limited to)
+     * when a window is added, removed, resized or moved.
+     *
+     * a NULL list parameter or a numHwLayers of zero indicates that the
+     * entire composition will be handled by SurfaceFlinger with OpenGL ES.
+     *
+     * returns: 0 on success. An negative error code on error. If an error is
+     * returned, SurfaceFlinger will assume that none of the layer will be
+     * handled by the HWC.
+     */
+    int (*prepare)(struct hwc_composer_device *dev, hwc_layer_list_t* list);
+
+    /*
+     * (*set)() is used in place of eglSwapBuffers(), and assumes the same
+     * functionality, except it also commits the work list atomically with
+     * the actual eglSwapBuffers().
+     *
+     * The list parameter is guaranteed to be the same as the one returned
+     * from the last call to (*prepare)().
+     *
+     * When this call returns the caller assumes that:
+     *
+     * - the display will be updated in the near future with the content
+     *   of the work list, without artifacts during the transition from the
+     *   previous frame.
+     *
+     * - all objects are available for immediate access or destruction, in
+     *   particular, hwc_region_t::rects data and hwc_layer_t::layer's buffer.
+     *   Note that this means that immediately accessing (potentially from a
+     *   different process) a buffer used in this call will not result in
+     *   screen corruption, the driver must apply proper synchronization or
+     *   scheduling (eg: block the caller, such as gralloc_module_t::lock(),
+     *   OpenGL ES, Camera, Codecs, etc..., or schedule the caller's work
+     *   after the buffer is freed from the actual composition).
+     *
+     * a NULL list parameter or a numHwLayers of zero indicates that the
+     * entire composition has been handled by SurfaceFlinger with OpenGL ES.
+     * In this case, (*set)() behaves just like eglSwapBuffers().
+     *
+     * dpy, sur, and list are set to NULL to indicate that the screen is
+     * turning off. This happens WITHOUT prepare() being called first.
+     * This is a good time to free h/w resources and/or power
+     * the relevant h/w blocks down.
+     *
+     * IMPORTANT NOTE: there is an implicit layer containing opaque black
+     * pixels behind all the layers in the list.
+     * It is the responsibility of the hwcomposer module to make
+     * sure black pixels are output (or blended from).
+     *
+     * returns: 0 on success. An negative error code on error:
+     *    HWC_EGL_ERROR: eglGetError() will provide the proper error code
+     *    Another code for non EGL errors.
+     *
+     */
+    int (*set)(struct hwc_composer_device *dev,
+                hwc_display_t dpy,
+                hwc_surface_t sur,
+                hwc_layer_list_t* list);
+
+    /*
+     * This field is OPTIONAL and can be NULL.
+     *
+     * If non NULL it will be called by SurfaceFlinger on dumpsys
+     */
+    void (*dump)(struct hwc_composer_device* dev, char *buff, int buff_len);
+
+    /*
+     * This field is OPTIONAL and can be NULL.
+     *
+     * (*registerProcs)() registers a set of callbacks the h/w composer HAL
+     * can later use. It is FORBIDDEN to call any of the callbacks from
+     * within registerProcs(). registerProcs() must save the hwc_procs_t pointer
+     * which is needed when calling a registered callback.
+     * Each call to registerProcs replaces the previous set of callbacks.
+     * registerProcs is called with NULL to unregister all callbacks.
+     *
+     * Any of the callbacks can be NULL, in which case the corresponding
+     * functionality is not supported.
+     */
+    void (*registerProcs)(struct hwc_composer_device* dev,
+            hwc_procs_t const* procs);
+
+    /*
+     * This field is OPTIONAL and can be NULL.
+     * availability: HWC_DEVICE_API_VERSION_0_2
+     *
+     * Used to retrieve information about the h/w composer
+     *
+     * Returns 0 on success or -errno on error.
+     */
+    int (*query)(struct hwc_composer_device* dev, int what, int* value);
+
+    /*
+     * Reserved for future use. Must be NULL.
+     */
+    void* reserved_proc[4];
+
+    /*
+     * This field is OPTIONAL and can be NULL.
+     * availability: HWC_DEVICE_API_VERSION_0_3
+     */
+    hwc_methods_t const *methods;
+
+} hwc_composer_device_t;
+
+/** convenience API for opening and closing a device */
+
+static inline int hwc_open(const struct hw_module_t* module,
+        hwc_composer_device_t** device) {
+    return module->methods->open(module,
+            HWC_HARDWARE_COMPOSER, (struct hw_device_t**)device);
+}
+
+static inline int hwc_close(hwc_composer_device_t* device) {
+    return device->common.close(&device->common);
+}
+
+/*****************************************************************************/
+
+#endif /* ANDROID_INCLUDE_HARDWARE_HWCOMPOSER_V0_H */

=== added file 'include/test/mir_test/hw_mock.h'
--- include/test/mir_test/hw_mock.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test/hw_mock.h	2013-03-22 15:42:23 +0000
@@ -0,0 +1,64 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+#ifndef MIR_TEST_DOUBLES_MOCK_ANDROID_HWC_DEVICE_H_
+#define MIR_TEST_DOUBLES_MOCK_ANDROID_HWC_DEVICE_H_
+
+#include "mir_test_doubles/mock_android_alloc_device.h"
+#include "mir_test_doubles/mock_hwc_composer_device_1.h"
+
+#include <hardware/hardware.h>
+#include <gmock/gmock.h>
+#include <memory>
+
+namespace mir
+{
+namespace test
+{
+
+typedef struct hw_module_t hw_module;
+class HardwareModuleStub : public hw_module
+{
+public:
+    HardwareModuleStub(hw_device_t& device);
+
+    static int hw_open(const struct hw_module_t* module, const char*, struct hw_device_t** device);
+    static int hw_close(struct hw_device_t*);
+
+    hw_module_methods_t gr_methods;
+    hw_device_t& mock_hw_device;
+};
+
+class HardwareAccessMock
+{
+public:
+    HardwareAccessMock();
+    ~HardwareAccessMock();
+
+    MOCK_METHOD2(hw_get_module, int(const char *id, const struct hw_module_t**));
+
+    std::shared_ptr<alloc_device_t> mock_alloc_device; 
+    std::shared_ptr<hwc_composer_device_1> mock_hwc_device;
+ 
+    std::shared_ptr<HardwareModuleStub> mock_gralloc_module;
+    std::shared_ptr<HardwareModuleStub> mock_hwc_module;
+};
+
+}
+}
+
+#endif /* MIR_TEST_DOUBLES_MOCK_ANDROID_HWC_DEVICE_H_ */

=== added file 'include/test/mir_test_doubles/mock_hwc_composer_device_1.h'
--- include/test/mir_test_doubles/mock_hwc_composer_device_1.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/mock_hwc_composer_device_1.h	2013-03-22 15:42:23 +0000
@@ -0,0 +1,44 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_MOCK_HWC_COMPOSER_DEVICE_1_H_
+#define MIR_TEST_DOUBLES_MOCK_HWC_COMPOSER_DEVICE_1_H_
+
+#include <hardware/hwcomposer.h>
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+class MockHWCComposerDevice1 : public hwc_composer_device_1
+{
+public:
+    MockHWCComposerDevice1()
+    {
+        common.version = HWC_DEVICE_API_VERSION_1_1;
+    } 
+};
+
+}
+}
+}
+
+#endif /* MIR_TEST_DOUBLES_MOCK_HWC_COMPOSER_DEVICE_1_H_ */

=== modified file 'src/server/graphics/android/CMakeLists.txt'
--- src/server/graphics/android/CMakeLists.txt	2013-03-21 03:32:59 +0000
+++ src/server/graphics/android/CMakeLists.txt	2013-03-22 15:42:23 +0000
@@ -12,7 +12,9 @@
   android_buffer.cpp
   android_buffer_handle.cpp
   android_display.cpp
+  android_display_selector.cpp
   android_framebuffer_window.cpp
+  android_fb_factory.cpp
   android_alloc_adaptor.cpp
 )
 

=== modified file 'src/server/graphics/android/android_alloc_adaptor.cpp'
--- src/server/graphics/android/android_alloc_adaptor.cpp	2013-03-13 04:54:15 +0000
+++ src/server/graphics/android/android_alloc_adaptor.cpp	2013-03-22 15:42:23 +0000
@@ -74,6 +74,7 @@
     ret = alloc_dev->alloc(alloc_dev.get(), (int) size.width.as_uint32_t(), (int) size.height.as_uint32_t(),
                            format, usage_flag, &buf_handle, &stride_as_int);
 
+    //todo: kdub we should not be passing an empty ptr around like this
     AndroidBufferHandleEmptyDeleter empty_del;
     AndroidBufferHandle *null_handle = NULL;
     if (( ret ) || (buf_handle == NULL) || (stride_as_int == 0))

=== added file 'src/server/graphics/android/android_display_selector.cpp'
--- src/server/graphics/android/android_display_selector.cpp	1970-01-01 00:00:00 +0000
+++ src/server/graphics/android/android_display_selector.cpp	2013-03-22 15:42:23 +0000
@@ -0,0 +1,58 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#include "android_display_selector.h"
+#include "android_fb_factory.h"
+
+#include <hardware/hwcomposer.h>
+
+namespace mg=mir::graphics;
+namespace mga=mir::graphics::android;
+
+mga::AndroidDisplaySelector::AndroidDisplaySelector(std::shared_ptr<mga::FBFactory> const& factory)
+    : fb_factory(factory) 
+{
+    const hw_module_t *hw_module;
+    int rc = hw_get_module(HWC_HARDWARE_MODULE_ID, &hw_module);
+
+    if (rc != 0)
+    {
+        /* could not find hw module. use GL fallback */
+        allocate_primary_fb = std::bind(&FBFactory::create_gpu_display, fb_factory);
+        return;
+    }
+
+    hw_device_t* hwc_device;
+    rc = hw_module->methods->open(hw_module, HWC_HARDWARE_COMPOSER, &hwc_device);
+
+    if ((hwc_device != nullptr) &&
+        (rc == 0 ) &&
+        (hwc_device->version == HWC_DEVICE_API_VERSION_1_1))
+    {
+        allocate_primary_fb = std::bind(&FBFactory::create_hwc1_1_gpu_display, fb_factory);
+    }
+    else
+    {
+        allocate_primary_fb = std::bind(&FBFactory::create_gpu_display, fb_factory);
+    }
+}
+ 
+std::shared_ptr<mg::Display> mga::AndroidDisplaySelector::primary_display()
+{
+    return allocate_primary_fb();
+}

=== added file 'src/server/graphics/android/android_display_selector.h'
--- src/server/graphics/android/android_display_selector.h	1970-01-01 00:00:00 +0000
+++ src/server/graphics/android/android_display_selector.h	2013-03-22 15:42:23 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_GRAPHICS_ANDROID_ANDROID_DISPLAY_SELECTOR_H_
+#define MIR_GRAPHICS_ANDROID_ANDROID_DISPLAY_SELECTOR_H_
+
+#include "display_selector.h"
+
+namespace mir
+{
+namespace graphics
+{
+
+class Display;
+
+namespace android
+{
+
+class FBFactory;
+
+class AndroidDisplaySelector : public DisplaySelector
+{
+public:
+    AndroidDisplaySelector(std::shared_ptr<FBFactory> const& factory); 
+    std::shared_ptr<Display> primary_display();
+
+private:
+    std::shared_ptr<FBFactory> fb_factory;
+    std::shared_ptr<Display> primary_hwc_display;
+    std::function<std::shared_ptr<Display>()> allocate_primary_fb;
+};
+
+}
+}
+}
+
+#endif /* MIR_GRAPHICS_ANDROID_ANDROID_DISPLAY_SELECTOR_H_ */

=== added file 'src/server/graphics/android/android_fb_factory.cpp'
--- src/server/graphics/android/android_fb_factory.cpp	1970-01-01 00:00:00 +0000
+++ src/server/graphics/android/android_fb_factory.cpp	2013-03-22 15:42:23 +0000
@@ -0,0 +1,44 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#include "android_fb_factory.h"
+#include "android_framebuffer_window.h"
+#include "android_display.h"
+
+#include <ui/FramebufferNativeWindow.h>
+#include <boost/throw_exception.hpp>
+
+namespace mg=mir::graphics;
+namespace mga=mir::graphics::android;
+
+std::shared_ptr<mg::Display> mga::AndroidFBFactory::create_hwc1_1_gpu_display() const
+{
+    //TODO: this will construct the hwc 1.1 framebuffer later
+    return create_gpu_display();
+}
+
+/* note: gralloc seems to choke when this is opened/closed more than once per process. must investigate drivers further */
+std::shared_ptr<mg::Display> mga::AndroidFBFactory::create_gpu_display() const
+{
+    auto android_window = std::make_shared< ::android::FramebufferNativeWindow>();
+    if (!android_window.get())
+        BOOST_THROW_EXCEPTION(std::runtime_error("could not open FB window"));
+    auto window = std::make_shared<mga::AndroidFramebufferWindow> (android_window);
+
+    return std::make_shared<mga::AndroidDisplay>(window);
+}

=== added file 'src/server/graphics/android/android_fb_factory.h'
--- src/server/graphics/android/android_fb_factory.h	1970-01-01 00:00:00 +0000
+++ src/server/graphics/android/android_fb_factory.h	2013-03-22 15:42:23 +0000
@@ -0,0 +1,42 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_GRAPHICS_ANDROID_ANDROID_FB_FACTORY_H_
+#define MIR_GRAPHICS_ANDROID_ANDROID_FB_FACTORY_H_
+
+#include "fb_factory.h"
+
+namespace mir
+{
+namespace graphics
+{
+namespace android
+{
+
+class AndroidFBFactory : public FBFactory
+{
+public:
+    std::shared_ptr<Display> create_hwc1_1_gpu_display() const;
+    std::shared_ptr<Display> create_gpu_display() const;
+};
+
+}
+}
+}
+
+#endif /* MIR_GRAPHICS_ANDROID_ANDROID_FB_FACTORY_H_ */

=== modified file 'src/server/graphics/android/android_platform.cpp'
--- src/server/graphics/android/android_platform.cpp	2013-03-21 03:32:59 +0000
+++ src/server/graphics/android/android_platform.cpp	2013-03-22 15:42:23 +0000
@@ -20,16 +20,11 @@
 #include "android_platform.h"
 #include "android_buffer_allocator.h"
 #include "android_display.h"
-#include "android_framebuffer_window.h"
+#include "android_display_selector.h"
+#include "android_fb_factory.h"
 #include "mir/graphics/platform_ipc_package.h"
 #include "mir/compositor/buffer_id.h"
 
-#include <ui/FramebufferNativeWindow.h>
-
-#include <boost/throw_exception.hpp>
-
-#include <stdexcept>
-
 namespace mg=mir::graphics;
 namespace mga=mir::graphics::android;
 namespace mc=mir::compositor;
@@ -42,9 +37,9 @@
 
 std::shared_ptr<mg::Display> mga::AndroidPlatform::create_display()
 {
-    auto android_window = std::make_shared< ::android::FramebufferNativeWindow>();
-    auto window = std::make_shared<mga::AndroidFramebufferWindow> (android_window);
-    return std::make_shared<mga::AndroidDisplay>(window);
+    auto fb_factory = std::make_shared<mga::AndroidFBFactory>();
+    auto selector = std::make_shared<mga::AndroidDisplaySelector>(fb_factory);
+    return selector->primary_display();
 }
 
 std::shared_ptr<mg::PlatformIPCPackage> mga::AndroidPlatform::get_ipc_package()

=== added file 'src/server/graphics/android/display_selector.h'
--- src/server/graphics/android/display_selector.h	1970-01-01 00:00:00 +0000
+++ src/server/graphics/android/display_selector.h	2013-03-22 15:42:23 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_GRAPHICS_ANDROID_DISPLAY_SELECTOR_H_
+#define MIR_GRAPHICS_ANDROID_DISPLAY_SELECTOR_H_
+
+#include <memory>
+
+namespace mir
+{
+namespace graphics
+{
+
+class Display;
+namespace android
+{
+
+class DisplaySelector
+{
+public:
+    virtual std::shared_ptr<Display> primary_display() = 0; 
+    virtual ~DisplaySelector() {}
+
+protected:
+    DisplaySelector() = default;
+    DisplaySelector& operator=(DisplaySelector const&) = delete;
+    DisplaySelector(DisplaySelector const&) = delete;
+};
+
+}
+}
+}
+
+#endif /* MIR_GRAPHICS_ANDROID_DISPLAY_SELECTOR_H_ */

=== added file 'src/server/graphics/android/fb_factory.h'
--- src/server/graphics/android/fb_factory.h	1970-01-01 00:00:00 +0000
+++ src/server/graphics/android/fb_factory.h	2013-03-22 15:42:23 +0000
@@ -0,0 +1,56 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_GRAPHICS_ANDROID_FB_FACTORY_H_
+#define MIR_GRAPHICS_ANDROID_FB_FACTORY_H_
+
+#include <memory>
+
+namespace mir
+{
+namespace graphics
+{
+class Display;
+
+namespace android
+{
+
+class FBFactory
+{
+public:
+    virtual ~FBFactory() {}
+
+    //creates a display that will render primarily via the gpu and OpenGLES 2.0, but will use the hwc
+    //module (version 1.1) for additional functionality, such as vsync timings, and hotplug detection 
+    virtual std::shared_ptr<Display> create_hwc1_1_gpu_display() const = 0;
+
+    //creates a display that will render primarily via the gpu and OpenGLES 2.0. Primarily a fall-back mode,
+    //this display is similar to what Android does when /system/lib/hw/hwcomposer.*.so modules are not present 
+    virtual std::shared_ptr<Display> create_gpu_display() const = 0;
+
+protected:
+    FBFactory() = default;
+    FBFactory& operator=(FBFactory const&) = delete;
+    FBFactory(FBFactory const&) = delete;
+};
+
+}
+}
+}
+
+#endif /* MIR_GRAPHICS_ANDROID_FB_FACTORY_H_ */

=== modified file 'tests/unit-tests/client/test_client_platform.cpp'
--- tests/unit-tests/client/test_client_platform.cpp	2013-01-02 15:57:13 +0000
+++ tests/unit-tests/client/test_client_platform.cpp	2013-03-22 15:42:23 +0000
@@ -22,6 +22,10 @@
 #include "mir_test_doubles/mock_client_context.h"
 #include "mir_test_doubles/mock_client_surface.h"
 
+#ifdef ANDROID
+#include "mir_test/hw_mock.h"
+#endif
+
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
@@ -29,7 +33,14 @@
 namespace mt = mir::test;
 namespace mtd = mt::doubles;
 
-TEST(ClientPlatformTest, platform_creates )
+class ClientPlatformTest : public ::testing::Test
+{
+#ifdef ANDROID
+    testing::NiceMock<mt::HardwareAccessMock> hw_access_mock;
+#endif
+};
+
+TEST_F(ClientPlatformTest, platform_creates)
 {
     mtd::MockClientContext context;
     mcl::NativeClientPlatformFactory factory;
@@ -38,7 +49,7 @@
     EXPECT_NE( depository.get(), (mcl::ClientBufferDepository*) NULL);
 }
 
-TEST(ClientPlatformTest, platform_creates_native_window )
+TEST_F(ClientPlatformTest, platform_creates_native_window)
 {
     mtd::MockClientContext context;
     mcl::NativeClientPlatformFactory factory;
@@ -48,7 +59,7 @@
     EXPECT_NE( *native_window, (EGLNativeWindowType) NULL);
 }
 
-TEST(ClientPlatformTest, platform_creates_egl_native_display)
+TEST_F(ClientPlatformTest, platform_creates_egl_native_display)
 {
     mtd::MockClientContext context;
     mcl::NativeClientPlatformFactory factory;

=== modified file 'tests/unit-tests/graphics/android/CMakeLists.txt'
--- tests/unit-tests/graphics/android/CMakeLists.txt	2013-03-13 04:54:15 +0000
+++ tests/unit-tests/graphics/android/CMakeLists.txt	2013-03-22 15:42:23 +0000
@@ -3,6 +3,7 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_buffer_allocator.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_buffer_tex_bind.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_fb.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_android_framebuffer_selector.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_framebuffer_window.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_alloc_adaptor.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_alloc_adaptor_native_win.cpp

=== modified file 'tests/unit-tests/graphics/android/test_android_buffer_allocator.cpp'
--- tests/unit-tests/graphics/android/test_android_buffer_allocator.cpp	2013-03-21 03:32:59 +0000
+++ tests/unit-tests/graphics/android/test_android_buffer_allocator.cpp	2013-03-22 15:42:23 +0000
@@ -17,32 +17,44 @@
  */
 
 #include "src/server/graphics/android/android_buffer_allocator.h"
+#include "mir_test/hw_mock.h"
 #include "mir/graphics/buffer_initializer.h"
 #include "mir/compositor/buffer_properties.h"
 
 #include "mir_test_doubles/mock_buffer_initializer.h"
 
+#include <hardware/gralloc.h>
 #include <gtest/gtest.h>
-
 #include <algorithm>
 
 namespace mg = mir::graphics;
 namespace mga = mir::graphics::android;
 namespace geom = mir::geometry;
+namespace mt = mir::test;
 namespace mc = mir::compositor;
 namespace mtd = mir::test::doubles;
 
-class AndroidBufferAllocatorTest : public ::testing::Test
+struct AndroidBufferAllocatorTest : public ::testing::Test
 {
-public:
     AndroidBufferAllocatorTest()
         : null_buffer_initializer{std::make_shared<mg::NullBufferInitializer>()}
     {
     }
 
     std::shared_ptr<mg::BufferInitializer> const null_buffer_initializer;
+    testing::NiceMock<mt::HardwareAccessMock> hw_access_mock;
 };
 
+TEST_F(AndroidBufferAllocatorTest, allocator_accesses_gralloc_module)
+{
+    using namespace testing;
+
+    EXPECT_CALL(hw_access_mock, hw_get_module(StrEq(GRALLOC_HARDWARE_MODULE_ID), _))
+        .Times(1);
+
+    mga::AndroidBufferAllocator allocator(null_buffer_initializer);
+}
+
 TEST_F(AndroidBufferAllocatorTest, supported_pixel_formats_contain_common_formats)
 {
     mga::AndroidBufferAllocator allocator{null_buffer_initializer};

=== added file 'tests/unit-tests/graphics/android/test_android_framebuffer_selector.cpp'
--- tests/unit-tests/graphics/android/test_android_framebuffer_selector.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/graphics/android/test_android_framebuffer_selector.cpp	2013-03-22 15:42:23 +0000
@@ -0,0 +1,127 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#include "src/server/graphics/android/fb_factory.h"
+#include "src/server/graphics/android/android_display_selector.h"
+
+#include "mir_test/hw_mock.h"
+#include "mir_test_doubles/null_display.h"
+
+#include <hardware/hwcomposer.h>
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+namespace mt=mir::test;
+namespace mtd=mir::test::doubles;
+namespace mga=mir::graphics::android;
+namespace mg=mir::graphics;
+namespace geom=mir::geometry;
+
+struct MockFbFactory : public mga::FBFactory
+{
+    MockFbFactory()
+    {
+        using namespace testing;
+        ON_CALL(*this, create_hwc1_1_gpu_display())
+            .WillByDefault(Return(std::make_shared<mtd::NullDisplay>()));
+        ON_CALL(*this, create_gpu_display())
+            .WillByDefault(Return(std::make_shared<mtd::NullDisplay>()));
+    }
+    MOCK_CONST_METHOD0(create_hwc1_1_gpu_display, std::shared_ptr<mg::Display>());
+    MOCK_CONST_METHOD0(create_gpu_display, std::shared_ptr<mg::Display>());
+ 
+};
+
+class AndroidFramebufferSelectorTest : public ::testing::Test
+{
+public:
+    AndroidFramebufferSelectorTest()
+        : mock_fb_factory(std::make_shared<testing::NiceMock<MockFbFactory>>())
+    {
+    }
+
+    std::shared_ptr<MockFbFactory> mock_fb_factory;
+    mt::HardwareAccessMock hw_access_mock;
+};
+
+TEST_F(AndroidFramebufferSelectorTest, hwc_selection_gets_hwc_device)
+{
+    using namespace testing;
+
+    EXPECT_CALL(hw_access_mock, hw_get_module(StrEq(HWC_HARDWARE_MODULE_ID), _))
+        .Times(1);
+
+    mga::AndroidDisplaySelector selector(mock_fb_factory);
+    selector.primary_display();
+}
+
+TEST_F(AndroidFramebufferSelectorTest, hwc_with_hwc_device_success)
+{
+    using namespace testing;
+
+    EXPECT_CALL(hw_access_mock, hw_get_module(_, _))
+        .Times(1);
+    EXPECT_CALL(*mock_fb_factory, create_hwc1_1_gpu_display())
+        .Times(1); 
+
+    mga::AndroidDisplaySelector selector(mock_fb_factory);
+    selector.primary_display();
+}
+
+TEST_F(AndroidFramebufferSelectorTest, hwc_with_hwc_device_failure_because_module_not_found)
+{
+    using namespace testing;
+
+    EXPECT_CALL(hw_access_mock, hw_get_module(_, _))
+        .Times(1)
+        .WillOnce(Return(-1));
+    EXPECT_CALL(*mock_fb_factory, create_gpu_display())
+        .Times(1); 
+
+    mga::AndroidDisplaySelector selector(mock_fb_factory);
+    selector.primary_display();
+}
+
+TEST_F(AndroidFramebufferSelectorTest, hwc_with_hwc_device_failure_because_hwc_does_not_open)
+{
+    using namespace testing;
+
+    EXPECT_CALL(hw_access_mock, hw_get_module(StrEq(HWC_HARDWARE_MODULE_ID), _))
+        .Times(1)
+        .WillOnce(DoAll(SetArgPointee<1>(nullptr), Return(-1)));
+;
+    EXPECT_CALL(*mock_fb_factory, create_gpu_display())
+        .Times(1);
+
+    mga::AndroidDisplaySelector selector(mock_fb_factory);
+    selector.primary_display();
+}
+
+TEST_F(AndroidFramebufferSelectorTest, hwc_with_hwc_device_failure_because_hwc_version_not_supported)
+{
+    using namespace testing;
+
+    hw_access_mock.mock_hwc_device->common.version = HWC_DEVICE_API_VERSION_1_0;
+    EXPECT_CALL(hw_access_mock, hw_get_module(_, _))
+        .Times(1);
+    EXPECT_CALL(*mock_fb_factory, create_gpu_display())
+        .Times(1);
+
+    mga::AndroidDisplaySelector selector(mock_fb_factory);
+    selector.primary_display();
+}

=== modified file 'tests/unit-tests/graphics/egl_mock/CMakeLists.txt'
--- tests/unit-tests/graphics/egl_mock/CMakeLists.txt	2013-03-13 04:54:15 +0000
+++ tests/unit-tests/graphics/egl_mock/CMakeLists.txt	2013-03-22 15:42:23 +0000
@@ -4,9 +4,16 @@
 
 set(UNIT_TEST_SOURCES ${UNIT_TEST_SOURCES} PARENT_SCOPE)
 
+set(MIRTEST_EGLMOCK_SOURCES 
+    gl_mock.cpp
+    egl_mock.cpp )
+
+if (MIR_PLATFORM STREQUAL "android")
+  list( APPEND MIRTEST_EGLMOCK_SOURCES hw_mock.cpp )
+endif()
+
 add_library(
   mirtest_eglmock STATIC
 
-  gl_mock.cpp
-  egl_mock.cpp
+  ${MIRTEST_EGLMOCK_SOURCES} 
 )

=== added file 'tests/unit-tests/graphics/egl_mock/hw_mock.cpp'
--- tests/unit-tests/graphics/egl_mock/hw_mock.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/graphics/egl_mock/hw_mock.cpp	2013-03-22 15:42:23 +0000
@@ -0,0 +1,86 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#include "mir_test/hw_mock.h"
+#include "mir_test_doubles/mock_hwc_composer_device_1.h"
+
+#include <hardware/gralloc.h>
+#include <system/window.h>
+#include <memory>
+
+namespace mt = mir::test;
+namespace mtd = mir::test::doubles;
+
+mt::HardwareModuleStub::HardwareModuleStub(hw_device_t& device)
+    : mock_hw_device(device)
+{ 
+    gr_methods.open = hw_open;
+    methods = &gr_methods; 
+}
+
+int mt::HardwareModuleStub::hw_open(const struct hw_module_t* module, const char*, struct hw_device_t** device)
+{
+    auto self = static_cast<HardwareModuleStub const*>(module);
+    self->mock_hw_device.close = hw_close;
+    *device = static_cast<hw_device_t*>(&self->mock_hw_device);
+    return 0;
+}
+
+int mt::HardwareModuleStub::hw_close(struct hw_device_t*)
+{
+    return 0;
+}
+
+namespace
+{
+mt::HardwareAccessMock* global_hw_mock = NULL;
+}
+
+mt::HardwareAccessMock::HardwareAccessMock()
+{
+    using namespace testing;
+    assert(global_hw_mock == NULL && "Only one mock object per process is allowed");
+    global_hw_mock = this;
+
+    mock_alloc_device = std::make_shared<mtd::MockAllocDevice>();
+    mock_gralloc_module = std::make_shared<mt::HardwareModuleStub>(mock_alloc_device->common);
+
+    mock_hwc_device = std::make_shared<mtd::MockHWCComposerDevice1>();
+    mock_hwc_module = std::make_shared<mt::HardwareModuleStub>(mock_hwc_device->common);
+
+    ON_CALL(*this, hw_get_module(StrEq(GRALLOC_HARDWARE_MODULE_ID),_))
+        .WillByDefault(DoAll(SetArgPointee<1>(mock_gralloc_module.get()), Return(0)));
+    ON_CALL(*this, hw_get_module(StrEq(HWC_HARDWARE_MODULE_ID),_))
+        .WillByDefault(DoAll(SetArgPointee<1>(mock_hwc_module.get()), Return(0)));
+}
+
+mt::HardwareAccessMock::~HardwareAccessMock()
+{
+    global_hw_mock = NULL;
+}
+
+int hw_get_module(const char *id, const struct hw_module_t **module)
+{
+    if (!global_hw_mock)
+    {
+        ADD_FAILURE_AT(__FILE__,__LINE__); \
+        return -1;
+    }
+    int rc =  global_hw_mock->hw_get_module(id, module);
+    return rc;
+}

=== modified file 'tests/unit-tests/graphics/test_graphics_platform.cpp'
--- tests/unit-tests/graphics/test_graphics_platform.cpp	2013-03-13 04:54:15 +0000
+++ tests/unit-tests/graphics/test_graphics_platform.cpp	2013-03-22 15:42:23 +0000
@@ -20,11 +20,13 @@
 #include "mir/graphics/platform.h"
 #include "mir/compositor/graphic_buffer_allocator.h"
 #include "mir/compositor/buffer_properties.h"
+#include "mir_test/egl_mock.h"
+#include "mir_test/gl_mock.h"
 #ifndef ANDROID
 #include "gbm/mock_drm.h"
 #include "gbm/mock_gbm.h"
-#include "mir_test/egl_mock.h"
-#include "mir_test/gl_mock.h"
+#else
+#include "mir_test/hw_mock.h"
 #endif
 #include "mir/graphics/buffer_initializer.h"
 #include "mir/logging/dumb_console_logger.h"
@@ -69,11 +71,14 @@
 
     std::shared_ptr<ml::Logger> logger;
     std::shared_ptr<mg::BufferInitializer> buffer_initializer;
-#ifndef ANDROID
+
+    ::testing::NiceMock<mir::EglMock> mock_egl;
+    ::testing::NiceMock<mir::GLMock> mock_gl;
+#ifdef ANDROID
+    mir::test::HardwareAccessMock hw_access_mock;
+#else
     ::testing::NiceMock<mg::gbm::MockDRM> mock_drm;
     ::testing::NiceMock<mg::gbm::MockGBM> mock_gbm;
-    ::testing::NiceMock<mir::EglMock> mock_egl;
-    ::testing::NiceMock<mir::GLMock> mock_gl;
 #endif
 };