path: root/tp-account-widgets/tpaw-camera-monitor.c

/*
 * Copyright (C) 2011 Collabora Ltd.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Authors: Emilio Pozuelo Monfort <emilio.pozuelo@collabora.co.uk>
 */

#include "config.h"
#include "tpaw-camera-monitor.h"

#include <tp-account-widgets/cheese-camera-device-monitor.h>

#define DEBUG_FLAG TPAW_DEBUG_OTHER
#include "tpaw-debug.h"

struct _TpawCameraMonitorPrivate
{
  TpawCameraDeviceMonitor *tpaw_monitor;
  GQueue *cameras;
  gint num_cameras;
};

enum
{
  PROP_0,
  PROP_AVAILABLE,
};

enum
{
  CAMERA_ADDED,
  CAMERA_REMOVED,
  LAST_SIGNAL
};

static guint signals[LAST_SIGNAL];

G_DEFINE_TYPE (TpawCameraMonitor, tpaw_camera_monitor, G_TYPE_OBJECT);

static TpawCameraMonitor *manager_singleton = NULL;

static TpawCamera *
tpaw_camera_new (const gchar *id,
    const gchar *device,
    const gchar *name)
{
  TpawCamera *camera = g_slice_new (TpawCamera);

  camera->id = g_strdup (id);
  camera->device = g_strdup (device);
  camera->name = g_strdup (name);

  return camera;
}

static TpawCamera *
tpaw_camera_copy (TpawCamera *camera)
{
  return tpaw_camera_new (camera->id, camera->device, camera->name);
}

static void
tpaw_camera_free (TpawCamera *camera)
{
  g_free (camera->id);
  g_free (camera->device);
  g_free (camera->name);

  g_slice_free (TpawCamera, camera);
}

G_DEFINE_BOXED_TYPE (TpawCamera, tpaw_camera,
    tpaw_camera_copy, tpaw_camera_free)

static gint
tpaw_camera_find (gconstpointer a,
    gconstpointer b)
{
  const TpawCamera *camera = a;
  const gchar *id = b;

  return g_strcmp0 (camera->id, id);
}

static void
tpaw_camera_monitor_free_camera_foreach (gpointer data,
    gpointer user_data)
{
  tpaw_camera_free (data);
}

static void
on_camera_added (TpawCameraDeviceMonitor *device,
    gchar *id,
    gchar *filename,
    gchar *product_name,
    gint api_version,
    TpawCameraMonitor *self)
{
  TpawCamera *camera;

  if (self->priv->cameras == NULL)
    return;

  camera = tpaw_camera_new (id, filename, product_name);

  g_queue_push_tail (self->priv->cameras, camera);

  self->priv->num_cameras++;

  if (self->priv->num_cameras == 1)
    g_object_notify (G_OBJECT (self), "available");

  g_signal_emit (self, signals[CAMERA_ADDED], 0, camera);
}

static void
on_camera_removed (TpawCameraDeviceMonitor *device,
    gchar *id,
    TpawCameraMonitor *self)
{
  TpawCamera *camera;
  GList *l;

  if (self->priv->cameras == NULL)
    return;

  l = g_queue_find_custom (self->priv->cameras, id, tpaw_camera_find);

  g_return_if_fail (l != NULL);

  camera = l->data;

  g_queue_delete_link (self->priv->cameras, l);

  self->priv->num_cameras--;

  if (self->priv->num_cameras == 0)
    g_object_notify (G_OBJECT (self), "available");

  g_signal_emit (self, signals[CAMERA_REMOVED], 0, camera);

  tpaw_camera_free (camera);
}

const GList *
tpaw_camera_monitor_get_cameras (TpawCameraMonitor *self)
{
  if (self->priv->cameras != NULL)
    return self->priv->cameras->head;
  else
    return NULL;
}

static void
tpaw_camera_monitor_get_property (GObject *object,
    guint prop_id,
    GValue *value,
    GParamSpec *pspec)
{
  TpawCameraMonitor *self = (TpawCameraMonitor *) object;

  switch (prop_id)
    {
    case PROP_AVAILABLE:
      g_value_set_boolean (value, self->priv->num_cameras > 0);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
tpaw_camera_monitor_dispose (GObject *object)
{
  TpawCameraMonitor *self = TPAW_CAMERA_MONITOR (object);

  tp_clear_object (&self->priv->tpaw_monitor);

  g_queue_foreach (self->priv->cameras,
      tpaw_camera_monitor_free_camera_foreach, NULL);
  tp_clear_pointer (&self->priv->cameras, g_queue_free);

  G_OBJECT_CLASS (tpaw_camera_monitor_parent_class)->dispose (object);
}

static void
tpaw_camera_monitor_constructed (GObject *object)
{
  TpawCameraMonitor *self = (TpawCameraMonitor *) object;

  G_OBJECT_CLASS (tpaw_camera_monitor_parent_class)->constructed (object);

  tpaw_camera_device_monitor_coldplug (self->priv->tpaw_monitor);
}

static void
tpaw_camera_monitor_class_init (TpawCameraMonitorClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  object_class->dispose = tpaw_camera_monitor_dispose;
  object_class->constructed = tpaw_camera_monitor_constructed;
  object_class->get_property = tpaw_camera_monitor_get_property;

  g_object_class_install_property (object_class, PROP_AVAILABLE,
      g_param_spec_boolean ("available", "Available",
      "Camera available", TRUE, G_PARAM_READABLE));

  signals[CAMERA_ADDED] =
      g_signal_new ("added", G_OBJECT_CLASS_TYPE (klass),
          G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
          0, NULL, NULL,
          g_cclosure_marshal_generic,
          G_TYPE_NONE, 1, TPAW_TYPE_CAMERA);

  signals[CAMERA_REMOVED] =
      g_signal_new ("removed", G_OBJECT_CLASS_TYPE (klass),
          G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
          0, NULL, NULL,
          g_cclosure_marshal_generic,
          G_TYPE_NONE, 1, TPAW_TYPE_CAMERA);

  g_type_class_add_private (object_class,
      sizeof (TpawCameraMonitorPrivate));
}

static void
tpaw_camera_monitor_init (TpawCameraMonitor *self)
{
  self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
      TPAW_TYPE_CAMERA_MONITOR, TpawCameraMonitorPrivate);

  self->priv->cameras = g_queue_new ();

  self->priv->tpaw_monitor = tpaw_camera_device_monitor_new ();

  g_signal_connect (self->priv->tpaw_monitor, "added",
      G_CALLBACK (on_camera_added), self);
  g_signal_connect (self->priv->tpaw_monitor, "removed",
      G_CALLBACK (on_camera_removed), self);

#ifndef HAVE_UDEV
  /* No udev, assume there are cameras present */
  self->priv->num_cameras = 1;
#endif
}

TpawCameraMonitor *
tpaw_camera_monitor_dup_singleton (void)
{
  GObject *retval;

  if (manager_singleton)
    {
      retval = g_object_ref (manager_singleton);
    }
  else
    {
      retval = g_object_new (TPAW_TYPE_CAMERA_MONITOR, NULL);

      manager_singleton = TPAW_CAMERA_MONITOR (retval);
      g_object_add_weak_pointer (retval, (gpointer) &manager_singleton);
    }

  return TPAW_CAMERA_MONITOR (retval);
}

TpawCameraMonitor *
tpaw_camera_monitor_new (void)
{
  return TPAW_CAMERA_MONITOR (
      g_object_new (TPAW_TYPE_CAMERA_MONITOR, NULL));
}

gboolean tpaw_camera_monitor_get_available (TpawCameraMonitor *self)
{
  g_return_val_if_fail (TPAW_IS_CAMERA_MONITOR (self), FALSE);

  return self->priv->num_cameras > 0;
}