Merge lp:~dandrader/frame/backend into lp:frame

[Daniel d'Andrada]

Adds a backend API.

So that any client can adapt frame+grail to work on top of their input system, without relying on frame to provide a suitable backend implementation.

This API also removes the need to mock libframe when writing grail tests.

Adds a backend API.

So that any client can adapt frame+grail to work on top of their input system, without relying on frame to provide a suitable backend implementation.

This API also removes the need to mock libframe when writing grail tests.

[Chase Douglas (chasedouglas)]

This is a great start! With a few changes we will hopefully be good to go :).

* The Doxygen comments for functions should have an extra newline between the summary and the extra description. The following function comments should be updated:
  frame_event_set_device()
  frame_device_add_axis()

* I would rather namespace the backend functions so they are clearly distinct from the frontend functions. For example, frame_device_new() should be frame_backend_device_new(), and frame_device_get_frontend() could be frame_backend_device_get_device().

* UFBackendDevice_ isn't an invariant because it is not fully initialized after the constructor returns. The constructor could be UFBackendDevice_(oif::frame::UFDevice* device), where the shared_ptr is initialized with the value of device. Then frame_backend_device_new() could simply be:

UFBackendDevice frame_device_new()
{
  return new UFBackendDevice_(new oif::frame::UFDevice);
}

This holds for UFBackendFrame and UFBackendTouch as well.

* Why can't we infer the number of axes from the number of added axes, rather than by having to manually set the value. The same for number of touches in the frame.

The simple fix would be to get the current value, increment it, then reinsert it into the device or frame when an axis or touch is added. The number of active touches would be set to the same value as the number of touches in the frame. The caller would need to set the total number of active touches *after* all frame touches have been added. A sanity check that the number of active touches is greater than or equal to the number of frame touches would be good.

* I understand how events are created, but how are they enqueued to a frame instance? How are devices added to a frame instance?

review: Needs Fixing

[Daniel d'Andrada (dandrader)]

> * Why can't we infer the number of axes from the number of added axes, rather
> than by having to manually set the value. The same for number of touches in
> the frame.

Because it's inefficient. If you add 10 items you will redefine the counter property 10 times.

It also hides the fact that number_of_foo is just a property that can be set independently from the entities they refer to. Besides, the idea of the backend interface is to enable the user to manually and directly build frame data as they will, to feed grail. No real logic expected here. All responsibility is in the hands of the user. The equivalent of a header defining some structs.

> * I understand how events are created, but how are they enqueued to a frame
> instance? How are devices added to a frame instance?

There's no need for a frame instance if you're using the backend interface. The whole point is that you manually create frame events to feed them to grail (through grail_process_frame_event). In that sense, libframe is reduced to being just a header defining some data containers that grail understands.

[Daniel d'Andrada (dandrader)]

> * I would rather namespace the backend functions so they are clearly distinct
> from the frontend functions. For example, frame_device_new() should be
> frame_backend_device_new(), and frame_device_get_frontend() could be
> frame_backend_device_get_device().

Makes all the sense.
I was striving for shorter function names. :)

[Daniel d'Andrada (dandrader)]

Updated according to comments (expect for auto-setting "count" properties)

[Chase Douglas (chasedouglas)]

* The frame_backend_device_delete() doxygen comment is a bit wonky, since it's one sentence split up for the summary and extended detail. It just needs to be slightly fixed up wording-wise.

* Daniel and I chatted on IRC about fixing up how the number of device axes and number of touches in a frame are calculated and reported. Those will be fixed in this proposal as well.

review: Needs Fixing

[Daniel d'Andrada (dandrader)]

> * The frame_backend_device_delete() doxygen comment is a bit wonky, since it's
> one sentence split up for the summary and extended detail. It just needs to be
> slightly fixed up wording-wise.

Yeah, that was a mistake. Autopilot was on when that happened.

>
> * Daniel and I chatted on IRC about fixing up how the number of device axes
> and number of touches in a frame are calculated and reported. Those will be
> fixed in this proposal as well.

Done.

[Chase Douglas (chasedouglas)]

* In frame_device_get_property(), the value parameter should be reinterpret_cast'd instead of static_cast'd. The same is true for frame_frame_get_property(). Casts from void* to a concrete pointer should always be reinterpret casted (according to thumper).

* frame_frame_get_property_unsigned_int_() has an erroneously added empty line at the top.

Everything else looks good. I'm approving based on these changes. Great stuff!

review: Approve

[lp:~dandrader/frame/backend]

90. By Daniel d'Andrada on 2012-08-29

Adds a backend API.

So that any client can adapt frame+grail to work on top of their input system
without relying on frame to provide a suitable backend implementation.

This API also removes the need to mock libframe when writing grail tests.

=== added file 'include/oif/frame_backend.h'
--- include/oif/frame_backend.h	1970-01-01 00:00:00 +0000
+++ include/oif/frame_backend.h	2012-08-29 18:56:18 +0000
@@ -0,0 +1,254 @@
+/**
+ * @file oif/frame_backend.h
+ * API for creating objects.
+ */
+
+#ifndef FRAME_OIF_FRAME_BACKEND_H_
+#define FRAME_OIF_FRAME_BACKEND_H_
+
+/* front end definitions */
+#include <oif/frame.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Handle for a device to be used on the backend API */
+typedef struct UFBackendDevice_* UFBackendDevice;
+
+/** Handle for a frame to be used on the backend API */
+typedef struct UFBackendFrame_* UFBackendFrame;
+
+/** Handle for a touch to be used on the backend API */
+typedef struct UFBackendTouch_* UFBackendTouch;
+
+/********************************************************************
+ * Event
+ ********************************************************************/
+
+/**
+ * Creates a new event with a reference count of one.
+ */
+FRAME_PUBLIC
+UFEvent frame_event_new();
+
+/**
+ * Sets the type of the given event
+ */
+FRAME_PUBLIC
+void frame_event_set_type(UFEvent event, UFEventType type);
+
+/**
+ * Sets the device property of the given event
+ *
+ * It increases the reference count of the corresponding UFDevice by one.
+ */
+FRAME_PUBLIC
+void frame_event_set_device(UFEvent event, UFBackendDevice device);
+
+/**
+ * Sets the frame property of the given event
+ *
+ * It increases the reference count of the corresponding UFFrame by one.
+ */
+FRAME_PUBLIC
+void frame_event_set_frame(UFEvent event, UFBackendFrame frame);
+
+/**
+ * Sets the time of the given event
+ */
+FRAME_PUBLIC
+void frame_event_set_time(UFEvent event, uint64_t time);
+
+/********************************************************************
+ * Device
+ ********************************************************************/
+
+/**
+ * Creates a new UFDevice and returns its backend handle.
+ */
+FRAME_PUBLIC
+UFBackendDevice frame_backend_device_new();
+
+/**
+ * Returns a UFDevice instance given its backend handle.
+ */
+FRAME_PUBLIC
+UFDevice frame_backend_device_get_device(UFBackendDevice device);
+
+/**
+ * Sets the "Name" property of the given device
+ */
+FRAME_PUBLIC
+void frame_backend_device_set_name(UFBackendDevice device, const char *name);
+
+/**
+ * Sets the "Direct" property of the given device
+ */
+FRAME_PUBLIC
+void frame_backend_device_set_direct(UFBackendDevice device, int direct);
+
+/**
+ * Sets the "Independent" property of the given device
+ */
+FRAME_PUBLIC
+void frame_backend_device_set_independent(UFBackendDevice device, int independent);
+
+/**
+ * Sets the "SemiMT" property of the given device
+ */
+FRAME_PUBLIC
+void frame_backend_device_set_semi_mt(UFBackendDevice device, int semi_mt);
+
+/**
+ * Sets the "MaxTouches" property of the given device
+ */
+FRAME_PUBLIC
+void frame_backend_device_set_max_touches(UFBackendDevice device, unsigned int max_touches);
+
+/**
+ * Sets the "WindowResolutionX" and "WindowResolutionY" properties of the
+ * given device.
+ */
+FRAME_PUBLIC
+void frame_backend_device_set_window_resolution(UFBackendDevice device, float x, float y);
+
+/**
+ * Adds an axis to the device
+ */
+FRAME_PUBLIC
+void frame_backend_device_add_axis(UFBackendDevice device,
+                                   UFAxisType type,
+                                   float min, float max, float resolution);
+
+/**
+ * Deletes the backend handle of a UFDevice, decreasing its reference count by one.
+ */
+FRAME_PUBLIC
+void frame_backend_device_delete(UFBackendDevice device);
+
+/********************************************************************
+ * Frame
+ ********************************************************************/
+
+/**
+ * Creates a new UFFrame and returns its backend handle.
+ */
+FRAME_PUBLIC
+UFBackendFrame frame_backend_frame_new();
+
+/**
+ * Returns a UFFrame instance given its backend handle.
+ */
+FRAME_PUBLIC
+UFFrame frame_backend_frame_get_frame(UFBackendFrame frame);
+
+/**
+ * Sets the "Device" property of the given frame
+ */
+FRAME_PUBLIC
+void frame_backend_frame_set_device(UFBackendFrame frame, UFBackendDevice device);
+
+/**
+ * Sets the "WindowId" property of the given frame
+ */
+FRAME_PUBLIC
+void frame_backend_frame_set_window_id(UFBackendFrame frame, UFWindowId window_id);
+
+/**
+ * Sets the "ActiveTouches" property of the given frame
+ *
+ * If unset this property returns the number of touches.
+ */
+FRAME_PUBLIC
+void frame_backend_frame_set_active_touches(UFBackendFrame frame, unsigned int active_touches);
+
+/**
+ * Adds a UFTouch to the given frame.
+ */
+FRAME_PUBLIC
+void frame_backend_frame_add_touch(UFBackendFrame frame, UFBackendTouch touch);
+
+/**
+ * Deletes the backend handle of a UFFrame,
+ * decreasing its reference count by one.
+ */
+FRAME_PUBLIC
+void frame_backend_frame_delete(UFBackendFrame frame);
+
+/********************************************************************
+ * Touch
+ ********************************************************************/
+
+/**
+ * Creates a new UFTouch and returns its backend handle.
+ */
+FRAME_PUBLIC
+UFBackendTouch frame_backend_touch_new();
+
+/**
+ * Returns a UFTouch instance given its backend handle.
+ */
+FRAME_PUBLIC
+UFTouch frame_backend_touch_get_touch(UFBackendTouch touch);
+
+/**
+ * Sets the "Id" property of the given touch
+ */
+FRAME_PUBLIC
+void frame_backend_touch_set_id(UFBackendTouch touch, UFTouchId id);
+
+/**
+ * Sets the "State" property of the given touch
+ */
+FRAME_PUBLIC
+void frame_backend_touch_set_state(UFBackendTouch touch, UFTouchState state);
+
+/**
+ * Sets the "WindowX" and "WindowY" properties of the given touch
+ */
+FRAME_PUBLIC
+void frame_backend_touch_set_window_pos(UFBackendTouch touch, float x, float y);
+
+/**
+ * Sets the "Time" property of the given touch
+ */
+FRAME_PUBLIC
+void frame_backend_touch_set_time(UFBackendTouch touch, uint64_t time);
+
+/**
+ * Sets the "StartTime" property of the given touch
+ */
+FRAME_PUBLIC
+void frame_backend_touch_set_start_time(UFBackendTouch touch, uint64_t start_time);
+
+/**
+ * Sets the "Owned" property of the given touch
+ */
+FRAME_PUBLIC
+void frame_backend_touch_set_owned(UFBackendTouch touch, int owned);
+
+/**
+ * Sets the "PendingEnd" property of the given touch
+ */
+FRAME_PUBLIC
+void frame_backend_touch_set_pending_end(UFBackendTouch touch, int pending_end);
+
+/**
+ * Sets the value of an axis of the given touch
+ */
+FRAME_PUBLIC
+void frame_backend_touch_set_value(UFBackendTouch touch, UFAxisType type, float value);
+
+/**
+ * Deletes the backend handle of a UFTouch,
+ * decreasing its reference count by one.
+ */
+FRAME_PUBLIC
+void frame_backend_touch_delete(UFBackendTouch touch);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FRAME_OIF_FRAME_BACKEND_H_ */
 
=== modified file 'src/device.cpp'
--- src/device.cpp	2012-06-21 19:41:40 +0000
+++ src/device.cpp	2012-08-29 18:56:18 +0000
@@ -24,6 +24,8 @@
 
 #include "axis.h"
 
+#include <oif/frame_backend.h>
+
 namespace oif {
 namespace frame {
 
@@ -75,18 +77,30 @@
 UFStatus frame_device_get_property_unsigned_int_(UFDevice device,
                                                  UFDeviceProperty property,
                                                  unsigned int *value) {
-  return static_cast<const oif::frame::UFDevice*>(device)->GetProperty(
-      property,
-      value);
+
+  if (property == UFDevicePropertyNumAxes) {
+    *value = static_cast<const oif::frame::UFDevice*>(device)->axes_.size();
+    return UFStatusSuccess;
+  } else {
+    return static_cast<const oif::frame::UFDevice*>(device)->GetProperty(
+        property,
+        value);
+  }
 }
 
 #undef frame_device_get_property /* Override C11 generic selections macro */
 FRAME_PUBLIC
 UFStatus frame_device_get_property(UFDevice device, UFDeviceProperty property,
                                    void *value) {
-  return static_cast<const oif::frame::UFDevice*>(device)->GetProperty(
-      property,
-      value);
+  if (property == UFDevicePropertyNumAxes) {
+    *reinterpret_cast<unsigned int *>(value) =
+      static_cast<const oif::frame::UFDevice*>(device)->axes_.size();
+    return UFStatusSuccess;
+  } else {
+    return static_cast<const oif::frame::UFDevice*>(device)->GetProperty(
+        property,
+        value);
+  }
 }
 
 UFStatus frame_device_get_axis_by_index(UFDevice device, unsigned int index,
@@ -129,4 +143,77 @@
   return resolution;
 }
 
+UFBackendDevice frame_backend_device_new()
+{
+  return new UFBackendDevice_(new oif::frame::UFDevice);
+}
+
+UFDevice frame_backend_device_get_device(UFBackendDevice device)
+{
+  return device->shared_ptr.get();
+}
+
+void frame_backend_device_delete(UFBackendDevice device)
+{
+  delete device;
+}
+
+void frame_backend_device_set_name(UFBackendDevice device, const char *name)
+{
+  static_cast<oif::frame::UFDevice*>(device->shared_ptr.get())->
+    InsertProperty(UFDevicePropertyName,
+                   new oif::frame::Value(name));
+}
+
+void frame_backend_device_set_direct(UFBackendDevice device, int direct)
+{
+  static_cast<oif::frame::UFDevice*>(device->shared_ptr.get())->
+    InsertProperty(UFDevicePropertyDirect,
+                   new oif::frame::Value(direct));
+}
+
+void frame_backend_device_set_independent(UFBackendDevice device, int independent)
+{
+  static_cast<oif::frame::UFDevice*>(device->shared_ptr.get())->
+    InsertProperty(UFDevicePropertyIndependent,
+                   new oif::frame::Value(independent));
+}
+
+void frame_backend_device_set_semi_mt(UFBackendDevice device, int semi_mt)
+{
+  static_cast<oif::frame::UFDevice*>(device->shared_ptr.get())->
+    InsertProperty(UFDevicePropertySemiMT,
+                   new oif::frame::Value(semi_mt));
+}
+
+void frame_backend_device_set_max_touches(UFBackendDevice device, unsigned int max_touches)
+{
+  static_cast<oif::frame::UFDevice*>(device->shared_ptr.get())->
+    InsertProperty(UFDevicePropertyMaxTouches,
+                   new oif::frame::Value(max_touches));
+}
+
+void frame_backend_device_set_window_resolution(UFBackendDevice device, float x, float y)
+{
+  static_cast<oif::frame::UFDevice*>(device->shared_ptr.get())->
+    InsertProperty(UFDevicePropertyWindowResolutionX,
+                   new oif::frame::Value(x));
+
+  static_cast<oif::frame::UFDevice*>(device->shared_ptr.get())->
+    InsertProperty(UFDevicePropertyWindowResolutionY,
+                   new oif::frame::Value(y));
+}
+
+void frame_backend_device_add_axis(UFBackendDevice device,
+                           UFAxisType type,
+                           float min, float max, float resolution)
+{
+  using oif::frame::UFAxis;
+
+  UFAxis_* axis = new UFAxis(type, min, max, resolution);
+
+  static_cast<oif::frame::UFDevice*>(device->shared_ptr.get())->
+    axes_[type] = std::unique_ptr<UFAxis>(static_cast<UFAxis*>(axis));
+}
+
 } // extern "C"
 
=== modified file 'src/device.h'
--- src/device.h	2012-06-21 19:41:40 +0000
+++ src/device.h	2012-08-29 18:56:18 +0000
@@ -32,6 +32,13 @@
   virtual ~UFDevice_() {};
 };
 
+struct UFBackendDevice_ {
+  UFBackendDevice_(oif::frame::UFDevice* device)
+    : shared_ptr(device) {}
+
+  oif::frame::SharedUFDevice shared_ptr;
+};
+
 namespace oif {
 namespace frame {
 
@@ -45,7 +52,6 @@
   UFDevice(const UFDevice&) = delete;
   UFDevice& operator=(const UFDevice&) = delete;
 
- protected:
   typedef std::unique_ptr<UFAxis> UniqueUFAxis;
 
   std::map<UFAxisType, UniqueUFAxis> axes_;
 
=== modified file 'src/event.cpp'
--- src/event.cpp	2012-06-21 19:41:40 +0000
+++ src/event.cpp	2012-08-29 18:56:18 +0000
@@ -22,10 +22,17 @@
 
 #include "event.h"
 #include "frame.h"
+#include "device.h"
+
+#include <oif/frame_backend.h>
 
 namespace oif {
 namespace frame {
 
+UFEvent::UFEvent()
+  : ref_count_(1) {
+}
+
 UFEvent::UFEvent(UFEventType type, const Value* data, uint64_t time)
     : ref_count_(1) {
   const Value* value;
@@ -70,6 +77,10 @@
 
 extern "C" {
 
+UFEvent frame_event_new() {
+  return new oif::frame::UFEvent;
+}
+
 void frame_event_ref(UFEvent event) {
   static_cast<oif::frame::UFEvent*>(event)->Ref();
 }
@@ -140,4 +151,30 @@
   return time;
 }
 
+void frame_event_set_type(UFEvent event, UFEventType type)
+{
+  static_cast<oif::frame::UFEvent*>(event)->
+    InsertProperty(UFEventPropertyType, new oif::frame::Value(type));
+}
+
+void frame_event_set_device(UFEvent event, UFBackendDevice device)
+{
+  static_cast<oif::frame::UFEvent*>(event)->
+    InsertProperty(UFEventPropertyDevice,
+                   new oif::frame::Value(device->shared_ptr));
+}
+
+void frame_event_set_frame(UFEvent event, UFBackendFrame frame)
+{
+  static_cast<oif::frame::UFEvent*>(event)->
+    InsertProperty(UFEventPropertyFrame,
+                   new oif::frame::Value(frame->shared_ptr));
+}
+
+void frame_event_set_time(UFEvent event, uint64_t time)
+{
+  static_cast<oif::frame::UFEvent*>(event)->
+    InsertProperty(UFEventPropertyTime, new oif::frame::Value(time));
+}
+
 } // extern "C"
 
=== modified file 'src/event.h'
--- src/event.h	2012-06-21 19:41:40 +0000
+++ src/event.h	2012-08-29 18:56:18 +0000
@@ -37,6 +37,7 @@
 
 class UFEvent : public UFEvent_, public Property<UFEventProperty> {
  public:
+  UFEvent();
   UFEvent(UFEventType type, const Value* data, uint64_t time);
   ~UFEvent();
 
 
=== modified file 'src/frame.cpp'
--- src/frame.cpp	2012-06-21 19:41:40 +0000
+++ src/frame.cpp	2012-08-29 18:56:18 +0000
@@ -23,9 +23,12 @@
 #include <assert.h>
 #include <stdio.h>
 
+#include "device.h"
 #include "touch.h"
 #include "window.h"
 
+#include <oif/frame_backend.h>
+
 namespace oif {
 namespace frame {
 
@@ -93,6 +96,12 @@
 
 } // namespace
 
+void UFFrame::AddTouch(const SharedUFTouch& touch)
+{
+  touches_map_[touch->id()] = touches_array_.size();
+  touches_array_.push_back(touch);
+}
+
 void UFFrame::UpdateTouch(const SharedUFTouch& touch) {
   auto map_it = touches_map_.find(touch->id());
 
@@ -102,14 +111,7 @@
         CopyStartTime(touches_array_[map_it->second], touch);
         touches_array_[map_it->second] = touch;
       } else {
-        touches_map_[touch->id()] = touches_array_.size();
-        touches_array_.push_back(touch);
-
-        const Value *value;
-        value = new Value(static_cast<unsigned int>(touches_map_.size()));
-        InsertProperty(UFFramePropertyNumTouches, value);
-        value = new Value(static_cast<unsigned int>(touches_map_.size()));
-        InsertProperty(UFFramePropertyActiveTouches, value);
+        AddTouch(touch);
       }
       break;
 
@@ -211,8 +213,21 @@
                                                 UFFrameProperty property,
                                                 unsigned int *value) {
   const oif::frame::UFFrame* ufframe =
-      static_cast<const oif::frame::UFFrame*>(frame);
-  return ufframe->GetProperty(property, value);
+    static_cast<const oif::frame::UFFrame*>(frame);
+
+  if (property == UFFramePropertyNumTouches) {
+    *value = ufframe->GetNumTouches();
+    return UFStatusSuccess;
+  } else if (property == UFFramePropertyActiveTouches) {
+    UFStatus status = ufframe->GetProperty(property, value);
+    if (status != UFStatusSuccess) {
+      *value = ufframe->GetNumTouches();
+      status = UFStatusSuccess;
+    }
+    return status;
+  } else {
+    return ufframe->GetProperty(property, value);
+  }
 }
 
 #undef frame_frame_get_property /* Override C11 generic selections macro */
@@ -221,7 +236,20 @@
                                   void *value) {
   const oif::frame::UFFrame* ufframe =
       static_cast<const oif::frame::UFFrame*>(frame);
-  return ufframe->GetProperty(property, value);
+
+  if (property == UFFramePropertyNumTouches) {
+    *reinterpret_cast<unsigned int *>(value) = ufframe->GetNumTouches();
+    return UFStatusSuccess;
+  } else if (property == UFFramePropertyActiveTouches) {
+    UFStatus status = ufframe->GetProperty(property, value);
+    if (status != UFStatusSuccess) {
+      *reinterpret_cast<unsigned int *>(value) = ufframe->GetNumTouches();
+      status = UFStatusSuccess;
+    }
+    return status;
+  } else {
+    return ufframe->GetProperty(property, value);
+  }
 }
 
 UFStatus frame_frame_get_touch_by_index(UFFrame frame, unsigned int index,
@@ -269,13 +297,9 @@
 }
 
 uint32_t frame_frame_get_num_touches(UFFrame frame) {
-  unsigned int num_touches;
   const oif::frame::UFFrame* ufframe =
       static_cast<const oif::frame::UFFrame*>(frame);
-  UFStatus status = ufframe->GetProperty(UFFramePropertyNumTouches,
-                                         &num_touches);
-  assert(status == UFStatusSuccess);
-  return num_touches;
+  return ufframe->GetNumTouches();
 }
 
 UFDevice frame_frame_get_device(UFFrame frame) {
@@ -287,4 +311,46 @@
   return device;
 }
 
+UFBackendFrame frame_backend_frame_new()
+{
+  return new UFBackendFrame_(new oif::frame::UFFrame);
+}
+
+UFFrame frame_backend_frame_get_frame(UFBackendFrame frame)
+{
+  return frame->shared_ptr.get();
+}
+
+void frame_backend_frame_set_device(UFBackendFrame frame, UFBackendDevice device)
+{
+  static_cast<oif::frame::UFFrame*>(frame->shared_ptr.get())->
+    InsertProperty(UFFramePropertyDevice,
+                   new oif::frame::Value(device->shared_ptr));
+}
+
+void frame_backend_frame_set_window_id(UFBackendFrame frame, UFWindowId window_id)
+{
+  static_cast<oif::frame::UFFrame*>(frame->shared_ptr.get())->
+    InsertProperty(UFFramePropertyWindowId,
+                   new oif::frame::Value(window_id));
+}
+
+void frame_backend_frame_set_active_touches(UFBackendFrame frame, unsigned int active_touches)
+{
+  static_cast<oif::frame::UFFrame*>(frame->shared_ptr.get())->
+    InsertProperty(UFFramePropertyActiveTouches,
+                   new oif::frame::Value(active_touches));
+}
+
+void frame_backend_frame_add_touch(UFBackendFrame frame, UFBackendTouch touch)
+{
+  static_cast<oif::frame::UFFrame*>(frame->shared_ptr.get())->
+    AddTouch(touch->shared_ptr);
+}
+
+void frame_backend_frame_delete(UFBackendFrame frame)
+{
+  delete frame;
+}
+
 } // extern "C"
 
=== modified file 'src/frame.h'
--- src/frame.h	2012-06-21 19:41:40 +0000
+++ src/frame.h	2012-08-29 18:56:18 +0000
@@ -33,6 +33,13 @@
   virtual ~UFFrame_() {}
 };
 
+struct UFBackendFrame_ {
+  UFBackendFrame_(oif::frame::UFFrame* frame)
+    : shared_ptr(frame) {}
+
+  oif::frame::SharedUFFrame shared_ptr;
+};
+
 namespace oif {
 namespace frame {
 
@@ -43,8 +50,10 @@
 
   UFTouch* CopyTouch(UFTouchId touchid, UFTouchState new_state) const;
   bool IsTouchOwned(UFTouchId touchid);
+  void AddTouch(const SharedUFTouch& touch);
   void UpdateTouch(const SharedUFTouch& touch);
   bool IsEnded() const;
+  unsigned int GetNumTouches() const { return touches_array_.size(); }
   UFStatus GetPreviousTouchValue(const UFTouch* touch, UFAxisType type,
                                  float* value) const;
   UFStatus GetPreviousTouchProperty(const UFTouch* touch,
 
=== modified file 'src/libframe.ver'
--- src/libframe.ver	2012-06-21 19:41:40 +0000
+++ src/libframe.ver	2012-08-29 18:56:18 +0000
@@ -61,6 +61,40 @@
     frame_x11_get_touch_id;
     frame_x11_create_touch_id;
 
+    frame_event_new;
+    frame_event_set_type;
+    frame_event_set_device;
+    frame_event_set_frame;
+    frame_event_set_time;
+    frame_backend_device_new;
+    frame_backend_device_get_device;
+    frame_backend_device_delete;
+    frame_backend_device_set_name;
+    frame_backend_device_set_direct;
+    frame_backend_device_set_independent;
+    frame_backend_device_set_semi_mt;
+    frame_backend_device_set_max_touches;
+    frame_backend_device_set_window_resolution;
+    frame_backend_device_add_axis;
+    frame_backend_frame_new;
+    frame_backend_frame_get_frame;
+    frame_backend_frame_set_device;
+    frame_backend_frame_set_window_id;
+    frame_backend_frame_set_active_touches;
+    frame_backend_frame_add_touch;
+    frame_backend_frame_delete;
+    frame_backend_touch_new;
+    frame_backend_touch_get_touch;
+    frame_backend_touch_set_id;
+    frame_backend_touch_set_state;
+    frame_backend_touch_set_window_pos;
+    frame_backend_touch_set_time;
+    frame_backend_touch_set_start_time;
+    frame_backend_touch_set_owned;
+    frame_backend_touch_set_pending_end;
+    frame_backend_touch_set_value;
+    frame_backend_touch_delete;
+
   local:
     *;
 };
 
=== modified file 'src/touch.cpp'
--- src/touch.cpp	2012-06-21 19:41:40 +0000
+++ src/touch.cpp	2012-08-29 18:56:18 +0000
@@ -24,6 +24,8 @@
 
 #include "frame.h"
 
+#include <oif/frame_backend.h>
+
 namespace oif {
 namespace frame {
 
@@ -205,4 +207,82 @@
   return start_time;
 }
 
+UFBackendTouch frame_backend_touch_new()
+{
+  return new UFBackendTouch_(new oif::frame::UFTouch);
+}
+
+UFTouch frame_backend_touch_get_touch(UFBackendTouch touch)
+{
+  return touch->shared_ptr.get();
+}
+
+void frame_backend_touch_set_id(UFBackendTouch touch_backend, UFTouchId id)
+{
+  oif::frame::UFTouch *touch =
+    static_cast<oif::frame::UFTouch*>(touch_backend->shared_ptr.get());
+
+  touch->InsertProperty(UFTouchPropertyId, new oif::frame::Value(id));
+  touch->SetId(id);
+}
+
+void frame_backend_touch_set_state(UFBackendTouch touch_backend, UFTouchState state)
+{
+  oif::frame::UFTouch *touch =
+    static_cast<oif::frame::UFTouch*>(touch_backend->shared_ptr.get());
+
+  touch->InsertProperty(UFTouchPropertyState, new oif::frame::Value(state));
+  touch->SetState(state);
+}
+
+void frame_backend_touch_set_window_pos(UFBackendTouch touch, float x, float y)
+{
+  static_cast<oif::frame::UFTouch*>(touch->shared_ptr.get())->
+    InsertProperty(UFTouchPropertyWindowX,
+                   new oif::frame::Value(x));
+
+  static_cast<oif::frame::UFTouch*>(touch->shared_ptr.get())->
+    InsertProperty(UFTouchPropertyWindowY,
+                   new oif::frame::Value(y));
+}
+
+void frame_backend_touch_set_time(UFBackendTouch touch, uint64_t time)
+{
+  static_cast<oif::frame::UFTouch*>(touch->shared_ptr.get())->
+    InsertProperty(UFTouchPropertyTime,
+                   new oif::frame::Value(time));
+}
+
+void frame_backend_touch_set_start_time(UFBackendTouch touch, uint64_t start_time)
+{
+  static_cast<oif::frame::UFTouch*>(touch->shared_ptr.get())->
+    InsertProperty(UFTouchPropertyStartTime,
+                   new oif::frame::Value(start_time));
+}
+
+void frame_backend_touch_set_owned(UFBackendTouch touch, int owned)
+{
+  static_cast<oif::frame::UFTouch*>(touch->shared_ptr.get())->
+    InsertProperty(UFTouchPropertyOwned,
+                   new oif::frame::Value(owned));
+}
+
+void frame_backend_touch_set_pending_end(UFBackendTouch touch, int pending_end)
+{
+  static_cast<oif::frame::UFTouch*>(touch->shared_ptr.get())->
+    InsertProperty(UFTouchPropertyPendingEnd,
+                   new oif::frame::Value(pending_end));
+}
+
+void frame_backend_touch_set_value(UFBackendTouch touch, UFAxisType type, float value)
+{
+  static_cast<oif::frame::UFTouch*>(touch->shared_ptr.get())->
+    SetValue(type, value);
+}
+
+void frame_backend_touch_delete(UFBackendTouch touch)
+{
+  delete touch;
+}
+
 } // extern "C"
 
=== modified file 'src/touch.h'
--- src/touch.h	2012-06-21 19:41:40 +0000
+++ src/touch.h	2012-08-29 18:56:18 +0000
@@ -34,16 +34,27 @@
   virtual ~UFTouch_() {}
 };
 
+struct UFBackendTouch_ {
+  UFBackendTouch_(oif::frame::UFTouch* touch)
+    : shared_ptr(touch) {}
+
+  oif::frame::SharedUFTouch shared_ptr;
+};
+
 namespace oif {
 namespace frame {
 
 class UFTouch : public UFTouch_, public Property<UFTouchProperty> {
  public:
+  UFTouch() {}
   UFTouch(UFTouchState state, UFTouchId id, float x, float y,
            uint64_t time);
   UFTouch(const UFTouch& touch, UFTouchState new_state);
 
+  void SetId(UFTouchId id) { id_ = id; }
   UFTouchId id() const { return id_; }
+
+  void SetState(UFTouchState state) { state_ = state; }
   UFTouchState state() const { return state_; }
 
   void SetValue(UFAxisType type, float value);
@@ -53,8 +64,8 @@
   UFTouch& operator=(const UFTouch&) = delete;
 
  private:
-  const UFTouchId id_;
-  const UFTouchState state_;
+  UFTouchId id_;
+  UFTouchState state_;
   std::map<UFAxisType, float> values_;
 };
 
 
=== modified file 'src/x11/device_x11.cpp'
--- src/x11/device_x11.cpp	2012-06-21 19:41:40 +0000
+++ src/x11/device_x11.cpp	2012-08-29 18:56:18 +0000
@@ -135,9 +135,6 @@
     }
   }
 
-  value = new Value(static_cast<unsigned int>(axes_.size()));
-  InsertProperty(UFDevicePropertyNumAxes, value);
-
   /* X11 doesn't provide us the real physical resolution of the display */
   value = new Value(0.f);
   InsertProperty(UFDevicePropertyWindowResolutionX, value);
 
=== modified file 'test/regular/Makefile.am'
--- test/regular/Makefile.am	2012-07-25 22:36:11 +0000
+++ test/regular/Makefile.am	2012-08-29 18:56:18 +0000
@@ -38,6 +38,7 @@
 
 check_regular_SOURCES = \
 	accept-ended-touch.cpp \
+	backend.cpp \
 	frame-fixture.cpp \
 	frame-fixture.h
 
 
=== added file 'test/regular/backend.cpp'
--- test/regular/backend.cpp	1970-01-01 00:00:00 +0000
+++ test/regular/backend.cpp	2012-08-29 18:56:18 +0000
@@ -0,0 +1,206 @@
+#include <gtest/gtest.h>
+#include "oif/frame_backend.h"
+
+TEST(Backend, Touch)
+{
+  UFStatus status;
+
+  UFBackendTouch touch_backend = frame_backend_touch_new();
+  ASSERT_TRUE(touch_backend != nullptr);
+
+  UFTouch touch = frame_backend_touch_get_touch(touch_backend);
+  ASSERT_TRUE(touch != nullptr);
+
+  frame_backend_touch_set_id(touch_backend, 123);
+  ASSERT_EQ(123, frame_touch_get_id(touch));
+
+  frame_backend_touch_set_state(touch_backend, UFTouchStateUpdate);
+  ASSERT_EQ(UFTouchStateUpdate, frame_touch_get_state(touch));
+
+  frame_backend_touch_set_window_pos(touch_backend, 1.2f, 3.4f);
+  ASSERT_EQ(1.2f, frame_touch_get_window_x(touch));
+  ASSERT_EQ(3.4f, frame_touch_get_window_y(touch));
+
+  frame_backend_touch_set_time(touch_backend, 852);
+  ASSERT_EQ(852, frame_touch_get_time(touch));
+
+  frame_backend_touch_set_start_time(touch_backend, 555);
+  ASSERT_EQ(555, frame_touch_get_start_time(touch));
+
+  frame_backend_touch_set_owned(touch_backend, 1);
+  int owned = 0;
+  status = frame_touch_get_property(touch, UFTouchPropertyOwned, &owned);
+  ASSERT_EQ(UFStatusSuccess, status);
+  ASSERT_EQ(1, owned);
+
+  frame_backend_touch_set_pending_end(touch_backend, 1);
+  int pending_end = 0;
+  status = frame_touch_get_property(touch, UFTouchPropertyPendingEnd, &pending_end);
+  ASSERT_EQ(UFStatusSuccess, status);
+  ASSERT_EQ(1, pending_end);
+
+  frame_backend_touch_set_value(touch_backend, UFAxisTypeTouchMajor, 987.6f);
+  float touch_major = 0.0f;
+  status = frame_touch_get_value(touch, UFAxisTypeTouchMajor, &touch_major);
+  ASSERT_EQ(UFStatusSuccess, status);
+  ASSERT_EQ(987.6f, touch_major);
+
+  frame_backend_touch_delete(touch_backend);
+}
+
+TEST(Backend, Device)
+{
+  UFStatus status;
+
+  UFBackendDevice device_backend = frame_backend_device_new();
+  ASSERT_NE(nullptr, device_backend);
+
+  UFDevice device = frame_backend_device_get_device(device_backend);
+  ASSERT_NE(nullptr, device);
+
+  const char *name = nullptr;
+  status = frame_device_get_property(device, UFDevicePropertyName, &name);
+  ASSERT_EQ(UFStatusErrorUnknownProperty, status);
+  frame_backend_device_set_name(device_backend, "Hello World");
+  status = frame_device_get_property(device, UFDevicePropertyName, &name);
+  ASSERT_EQ(UFStatusSuccess, status);
+  ASSERT_STREQ("Hello World", name);
+
+  int direct = 0;
+  status = frame_device_get_property(device, UFDevicePropertyDirect, &direct);
+  ASSERT_EQ(UFStatusErrorUnknownProperty, status);
+  frame_backend_device_set_direct(device_backend, 1);
+  status = frame_device_get_property(device, UFDevicePropertyDirect, &direct);
+  ASSERT_EQ(UFStatusSuccess, status);
+  ASSERT_EQ(1, direct);
+
+  int independent = 0;
+  status = frame_device_get_property(device, UFDevicePropertyIndependent, &independent);
+  ASSERT_EQ(UFStatusErrorUnknownProperty, status);
+  frame_backend_device_set_independent(device_backend, 1);
+  status = frame_device_get_property(device, UFDevicePropertyIndependent, &independent);
+  ASSERT_EQ(UFStatusSuccess, status);
+  ASSERT_EQ(1, independent);
+
+  int semi_mt = 0;
+  status = frame_device_get_property(device, UFDevicePropertySemiMT, &semi_mt);
+  ASSERT_EQ(UFStatusErrorUnknownProperty, status);
+  frame_backend_device_set_semi_mt(device_backend, 1);
+  status = frame_device_get_property(device, UFDevicePropertySemiMT, &semi_mt);
+  ASSERT_EQ(UFStatusSuccess, status);
+  ASSERT_EQ(1, semi_mt);
+
+  unsigned int max_touches = 0;
+  status = frame_device_get_property(device, UFDevicePropertyMaxTouches, &max_touches);
+  ASSERT_EQ(UFStatusErrorUnknownProperty, status);
+  frame_backend_device_set_max_touches(device_backend, 5);
+  status = frame_device_get_property(device, UFDevicePropertyMaxTouches, &max_touches);
+  ASSERT_EQ(UFStatusSuccess, status);
+  ASSERT_EQ(5, max_touches);
+
+  frame_backend_device_set_window_resolution(device_backend, 1024.0f, 768.0f);
+  ASSERT_EQ(1024.0f, frame_device_get_window_resolution_x(device));
+  ASSERT_EQ(768.0f, frame_device_get_window_resolution_y(device));
+
+  unsigned int num_axes = 0;
+  status = frame_device_get_property(device, UFDevicePropertyNumAxes, &num_axes);
+  ASSERT_EQ(UFStatusSuccess, status);
+  ASSERT_EQ(0, num_axes);
+  frame_backend_device_add_axis(device_backend,
+                        UFAxisTypePressure, 1.0f, 1000.0f, 3.5f);
+  status = frame_device_get_property(device, UFDevicePropertyNumAxes, &num_axes);
+  ASSERT_EQ(UFStatusSuccess, status);
+  ASSERT_EQ(1, num_axes);
+  UFAxis axis = nullptr;
+  status = frame_device_get_axis_by_type(device, UFAxisTypePressure, &axis);
+  ASSERT_EQ(UFStatusSuccess, status);
+  ASSERT_NE(nullptr, axis);
+  ASSERT_EQ(UFAxisTypePressure, frame_axis_get_type(axis));
+  ASSERT_EQ(1.0f, frame_axis_get_minimum(axis));
+  ASSERT_EQ(1000.0f, frame_axis_get_maximum(axis));
+  ASSERT_EQ(3.5f, frame_axis_get_resolution(axis));
+
+  frame_backend_device_delete(device_backend);
+}
+
+TEST(Backend, Frame)
+{
+  UFStatus status;
+
+  UFBackendFrame frame_backend = frame_backend_frame_new();
+  ASSERT_NE(nullptr, frame_backend);
+
+  UFFrame frame = frame_backend_frame_get_frame(frame_backend);
+  ASSERT_NE(nullptr, frame);
+
+  UFBackendDevice device_backend = frame_backend_device_new();
+  UFDevice device = frame_backend_device_get_device(device_backend);
+
+  frame_backend_frame_set_device(frame_backend, device_backend);
+  ASSERT_EQ(device, frame_frame_get_device(frame));
+
+  frame_backend_frame_set_window_id(frame_backend, 123);
+  ASSERT_EQ(123, frame_frame_get_window_id(frame));
+
+
+  unsigned int active_touches = 0;
+  UFBackendTouch touch_backend = frame_backend_touch_new();
+  UFTouch touch = frame_backend_touch_get_touch(touch_backend);
+  frame_backend_touch_set_id(touch_backend, 10);
+  UFTouch touch_retrieved = nullptr;
+  ASSERT_EQ(0, frame_frame_get_num_touches(frame));
+  status = frame_frame_get_property(frame, UFFramePropertyActiveTouches, &active_touches);
+  ASSERT_EQ(UFStatusSuccess, status);
+  ASSERT_EQ(0, active_touches);
+  frame_backend_frame_add_touch(frame_backend, touch_backend);
+  ASSERT_EQ(1, frame_frame_get_num_touches(frame));
+  status = frame_frame_get_property(frame, UFFramePropertyActiveTouches, &active_touches);
+  ASSERT_EQ(UFStatusSuccess, status);
+  ASSERT_EQ(1, active_touches);
+  status = frame_frame_get_touch_by_id(frame, 10, &touch_retrieved);
+  ASSERT_EQ(UFStatusSuccess, status);
+  ASSERT_EQ(touch, touch_retrieved);
+
+  frame_backend_frame_set_active_touches(frame_backend, 3);
+  status = frame_frame_get_property(frame, UFFramePropertyActiveTouches, &active_touches);
+  ASSERT_EQ(UFStatusSuccess, status);
+  ASSERT_EQ(3, active_touches);
+
+  frame_backend_frame_delete(frame_backend);
+  frame_backend_device_delete(device_backend);
+  frame_backend_touch_delete(touch_backend);
+}
+
+TEST(Backend, Event)
+{
+  UFStatus status;
+
+  UFEvent event = frame_event_new();
+  ASSERT_NE(nullptr, event);
+
+  frame_event_set_type(event, UFEventTypeDeviceRemoved);
+  ASSERT_EQ(UFEventTypeDeviceRemoved, frame_event_get_type(event));
+
+  UFBackendDevice device_backend = frame_backend_device_new();
+  UFDevice device = frame_backend_device_get_device(device_backend);
+  UFDevice device_retrieved = nullptr;
+  frame_event_set_device(event, device_backend);
+  status = frame_event_get_property(event, UFEventPropertyDevice, &device_retrieved);
+  ASSERT_EQ(UFStatusSuccess, status);
+  ASSERT_EQ(device, device_retrieved);
+
+  UFBackendFrame frame_backend = frame_backend_frame_new();
+  UFFrame frame = frame_backend_frame_get_frame(frame_backend);
+  UFFrame frame_retrieved = nullptr;
+  frame_event_set_frame(event, frame_backend);
+  status = frame_event_get_property(event, UFEventPropertyFrame, &frame_retrieved);
+  ASSERT_EQ(UFStatusSuccess, status);
+  ASSERT_EQ(frame, frame_retrieved);
+
+  frame_event_set_time(event, 1234);
+  ASSERT_EQ(1234, frame_event_get_time(event));
+
+  frame_event_unref(event);
+  frame_backend_device_delete(device_backend);
+  frame_backend_frame_delete(frame_backend);
+}