Changeset 1503

Show
Ignore:
Timestamp:
01/29/07 10:26:50
Author:
djcb
Message:

* ChangeLog?, Makefile.am, tny-maemo-device.c:

- implement tny-maemo-device (first version)

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/ChangeLog

    r1495 r1503  
     12007-01-29 Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com> 
     2 
     3        * Implement tny-maemo-device (first version) 
     4 
    152007-01-29  Philip Van Hoof  <pvanhoof@gnome.org> 
    26 
     
    2933        * This was a major API change 
    3034 
     35>>>>>>> .r1500 
    31362007-01-26  Sergio Villar Senin <svillar@igalia.com> 
    3237 
  • trunk/libtinymail-maemo/Makefile.am

    r1186 r1503  
    77        -I$(top_srcdir)/libtinymail-camel \ 
    88        -I$(top_srcdir)/libtinymail-camel/camel-lite \ 
    9         -I$(top_srcdir)/libtinymail-gnomevfs  
     9        -I$(top_srcdir)/libtinymail-gnomevfs \ 
     10        -DDBUS_API_SUBJECT_TO_CHANGE 
    1011 
    1112 
  • trunk/libtinymail-maemo/tny-maemo-device.c

    r971 r1503  
    1919 
    2020#include <config.h> 
    21  
     21#include <glib.h> 
     22#include <glib-object.h> 
    2223#include <glib/gi18n-lib.h> 
    23  
    2424#include <tny-maemo-device.h> 
     25#include <coniciap.h> 
     26#include <conicconnection.h> 
     27#include <conicconnectionevent.h> 
     28 
    2529 
    2630static GObjectClass *parent_class = NULL; 
    2731 
    28 #include "tny-maemo-device-priv.h" 
    29  
    30 static void tny_maemo_device_on_online (TnyDevice *self); 
    31 static void tny_maemo_device_on_offline (TnyDevice *self); 
    32 static gboolean tny_maemo_device_is_online (TnyDevice *self); 
     32typedef struct { 
     33        ConIcConnection *cnx; 
     34        gboolean        is_online; 
     35} TnyMaemoDevicePriv; 
     36 
     37#define TNY_MAEMO_DEVICE_GET_PRIVATE(o) \ 
     38        (G_TYPE_INSTANCE_GET_PRIVATE ((o), TNY_TYPE_MAEMO_DEVICE, TnyMaemoDevicePriv)) 
    3339 
    3440 
     
    3642tny_maemo_device_reset (TnyDevice *self) 
    3743{ 
    38         TnyMaemoDevicePriv *priv = TNY_MAEMO_DEVICE_GET_PRIVATE (self); 
    39  
    40         priv->fset = FALSE; 
    41         priv->forced = FALSE; 
    42  
    43 
     44        //TnyMaemoDevicePriv *priv = TNY_MAEMO_DEVICE_GET_PRIVATE (self); 
     45        /* FIXME: hmm... what to do here? */ 
     46
     47 
     48 
     49static void 
     50on_connection_event (ConIcConnection *self, ConIcConnectionEvent *event, gpointer user_data) 
     51
     52        TnyMaemoDevice *device;  
     53        TnyMaemoDevicePriv *priv; 
     54         
     55        g_return_if_fail (event); 
     56        g_return_if_fail (user_data); 
     57 
     58        device = TNY_MAEMO_DEVICE(user_data); 
     59        priv   = TNY_MAEMO_DEVICE_GET_PRIVATE (device); 
     60 
     61        /* FIXME: do something useful with errors */ 
     62        switch (con_ic_connection_event_get_error(event)) { 
     63        case CON_IC_CONNECTION_ERROR_NONE: 
     64                break; 
     65        case CON_IC_CONNECTION_ERROR_INVALID_IAP: 
     66                break; 
     67        case CON_IC_CONNECTION_ERROR_CONNECTION_FAILED: 
     68                break; 
     69        case CON_IC_CONNECTION_ERROR_USER_CANCELED: 
     70                break; 
     71        default: 
     72                g_return_if_reached (); 
     73        } 
     74 
     75        switch (con_ic_connection_event_get_status(event)) { 
     76                 
     77        case CON_IC_STATUS_CONNECTED: 
     78                priv->is_online = TRUE; 
     79                g_signal_emit (device, tny_device_signals [TNY_DEVICE_CONNECTION_CHANGED], 
     80                               0, TRUE); 
     81                break; 
     82 
     83        case CON_IC_STATUS_DISCONNECTED:                 
     84                priv->is_online = FALSE; 
     85                g_signal_emit (device, tny_device_signals [TNY_DEVICE_CONNECTION_CHANGED], 
     86                               0, FALSE); 
     87                break; 
     88        case CON_IC_STATUS_DISCONNECTING: 
     89                /* nothing to do */ 
     90                break; 
     91        default: 
     92                g_return_if_reached (); /* should not happen */ 
     93        } 
     94
     95 
     96 
    4497 
    4598static void  
    4699tny_maemo_device_force_online (TnyDevice *self) 
    47100{ 
    48         TnyMaemoDevicePriv *priv = TNY_MAEMO_DEVICE_GET_PRIVATE (self); 
    49  
    50         priv->fset = TRUE; 
    51         priv->forced = TRUE; 
    52  
    53         tny_maemo_device_on_online (self); 
    54  
    55         return; 
     101        TnyMaemoDevicePriv *priv;        
     102         
     103        g_return_if_fail (TNY_IS_DEVICE(self)); 
     104 
     105        priv   = TNY_MAEMO_DEVICE_GET_PRIVATE (self); 
     106 
     107        if (!con_ic_connection_connect (priv->cnx, 
     108                                        CON_IC_CONNECT_FLAG_NONE)) 
     109                g_warning ("could not send connect dbus message"); 
    56110} 
    57111 
     
    60114tny_maemo_device_force_offline (TnyDevice *self) 
    61115{ 
    62         TnyMaemoDevicePriv *priv = TNY_MAEMO_DEVICE_GET_PRIVATE (self); 
    63  
    64         priv->fset = TRUE; 
    65         priv->forced = FALSE; 
    66  
    67  
    68         tny_maemo_device_on_offline (self); 
    69          
    70         return; 
    71 
    72  
    73 static void 
    74 tny_maemo_device_on_online (TnyDevice *self) 
    75 
    76         g_signal_emit (self, tny_device_signals [TNY_DEVICE_CONNECTION_CHANGED], 0, TRUE); 
    77  
    78         return; 
    79 
    80  
    81 static void 
    82 tny_maemo_device_on_offline (TnyDevice *self) 
    83 
    84         g_signal_emit (self, tny_device_signals [TNY_DEVICE_CONNECTION_CHANGED], 0, FALSE); 
    85  
    86         return; 
    87 
     116        TnyMaemoDevicePriv *priv;        
     117 
     118        g_return_if_fail (TNY_IS_DEVICE(self)); 
     119 
     120        priv   = TNY_MAEMO_DEVICE_GET_PRIVATE (self); 
     121         
     122        if (!con_ic_connection_disconnect (priv->cnx)) 
     123                g_warning ("could not send disconnect dbus message"); 
     124
     125 
    88126 
    89127static gboolean 
    90128tny_maemo_device_is_online (TnyDevice *self) 
    91129{ 
    92         TnyMaemoDevicePriv *priv = TNY_MAEMO_DEVICE_GET_PRIVATE (self); 
    93         gboolean retval = FALSE; 
    94         return retval; 
     130        g_return_val_if_fail (TNY_IS_DEVICE(self), FALSE); 
     131         
     132        /* FIXME: get the info directly from iap? */ 
     133        return TNY_MAEMO_DEVICE_GET_PRIVATE (self)->is_online; 
    95134} 
    96135 
     
    100139        TnyMaemoDevice *self = (TnyMaemoDevice *)instance; 
    101140        TnyMaemoDevicePriv *priv = TNY_MAEMO_DEVICE_GET_PRIVATE (self); 
    102  
    103         return; 
     141         
     142        priv->is_online     = FALSE; /* FIXME: get this from IAP somehow? */ 
    104143} 
    105144 
     
    114153tny_maemo_device_new (void) 
    115154{ 
    116         TnyMaemoDevice *self = g_object_new (TNY_TYPE_MAEMO_DEVICE, NULL); 
    117  
     155        TnyMaemoDevice *self;  
     156        TnyMaemoDevicePriv *priv; 
     157 
     158        self = g_object_new (TNY_TYPE_MAEMO_DEVICE, NULL); 
     159        priv   = TNY_MAEMO_DEVICE_GET_PRIVATE (self); 
     160 
     161        priv->cnx = con_ic_connection_new (); 
     162        if (!priv->cnx) { 
     163                g_warning ("con_ic_connection_new failed"); 
     164                g_object_unref (self); 
     165                return NULL; 
     166        } 
     167 
     168        g_signal_connect (priv->cnx, "connection-event", 
     169                          G_CALLBACK(on_connection_event), self); 
     170         
    118171        return TNY_DEVICE (self); 
    119172} 
     
    121174 
    122175static void 
    123 tny_maemo_device_finalize (GObject *object) 
    124 
    125         (*parent_class->finalize) (object); 
    126  
    127         return; 
     176tny_maemo_device_finalize (GObject *obj) 
     177
     178        TnyMaemoDevicePriv *priv; 
     179        priv   = TNY_MAEMO_DEVICE_GET_PRIVATE (obj); 
     180 
     181        con_ic_connection_disconnect (priv->cnx); 
     182        g_object_unref (priv->cnx); 
     183        priv->cnx = NULL; 
     184         
     185        (*parent_class->finalize) (obj); 
    128186} 
    129187 
     
    134192        TnyDeviceIface *klass = (TnyDeviceIface *)g; 
    135193 
    136         klass->is_online_func = tny_maemo_device_is_online; 
    137         klass->reset_func = tny_maemo_device_reset; 
     194        klass->is_online_func     = tny_maemo_device_is_online; 
     195        klass->reset_func         = tny_maemo_device_reset; 
    138196        klass->force_offline_func = tny_maemo_device_force_offline; 
    139         klass->force_online_func = tny_maemo_device_force_online; 
    140  
    141         return; 
     197        klass->force_online_func  = tny_maemo_device_force_online; 
    142198} 
    143199 
     
    155211 
    156212        g_type_class_add_private (object_class, sizeof (TnyMaemoDevicePriv)); 
    157  
    158         return; 
    159213} 
    160214 
     
    194248 
    195249        } 
    196  
    197250        return type; 
    198251}