Changeset 3227

Show
Ignore:
Timestamp:
01/09/08 11:51:11
Author:
djcb
Message:

* small fixes to tny-maemo-conic-device

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/ChangeLog

    r3226 r3227  
     12008-01-09  Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com> 
     2         
     3        * small fixes / cleanups for tny-maemo-conic-device 
     4 
    152008-01-08  Sergio Villar Senin  <svillar@igalia.com> 
    26 
  • trunk/libtinymail-maemo/tny-maemo-conic-device.c

    r3226 r3227  
    8080conic_emit_status_idle (gpointer user_data) 
    8181{ 
    82         EmitStatusInfo *info = (EmitStatusInfo *) user_data; 
     82        EmitStatusInfo *info; 
     83 
     84        g_return_val_if_fail (user_data, FALSE); 
     85         
     86        info  = (EmitStatusInfo *) user_data; 
    8387 
    8488        /* We lock the gdk thread because tinymail wants implementations to do 
     
    97101conic_emit_status_destroy (gpointer user_data) 
    98102{ 
    99         EmitStatusInfo *info = (EmitStatusInfo *) user_data; 
    100         g_object_unref (info->self); 
     103        EmitStatusInfo *info; 
     104 
     105        g_return_if_fail (user_data); 
     106 
     107        info = (EmitStatusInfo *) user_data; 
     108         
     109        if (G_IS_OBJECT(info->self)) 
     110                g_object_unref (info->self); 
     111 
    101112        g_slice_free (EmitStatusInfo, info); 
    102         return; 
    103113} 
    104114 
     
    106116conic_emit_status (TnyDevice *self, gboolean status) 
    107117{ 
     118        EmitStatusInfo *info; 
     119        guint time = 1000; 
     120 
     121        g_return_if_fail (TNY_IS_DEVICE(self)); 
     122         
    108123        /* Emit it in an idle handler: */ 
    109         EmitStatusInfo *info = g_slice_new (EmitStatusInfo); 
    110         guint time = 1000; 
    111  
     124        info = g_slice_new (EmitStatusInfo); 
     125         
    112126        info->self = g_object_ref (self); 
    113127        info->status = status; 
     
    118132        g_timeout_add_full (G_PRIORITY_DEFAULT, time, conic_emit_status_idle, 
    119133                info, conic_emit_status_destroy); 
    120  
    121         return; 
    122134} 
    123135 
     
    130142 
    131143        g_return_if_fail (TNY_IS_DEVICE(device)); 
     144         
    132145        self = TNY_MAEMO_CONIC_DEVICE (device); 
    133146        priv = TNY_MAEMO_CONIC_DEVICE_GET_PRIVATE (self); 
     
    138151        if (status_before != tny_maemo_conic_device_is_online (device)) 
    139152                conic_emit_status (device, !status_before); 
    140  
    141         return; 
    142153} 
    143154 
     
    145156handle_connect (TnyMaemoConicDevice *self, int con_err, int con_state) 
    146157{ 
    147         TnyMaemoConicDevicePriv *priv = TNY_MAEMO_CONIC_DEVICE_GET_PRIVATE (self); 
     158        TnyMaemoConicDevicePriv *priv; 
     159 
     160        g_return_if_fail (TNY_IS_MAEMO_CONIC_DEVICE (self)); 
     161         
     162        priv = TNY_MAEMO_CONIC_DEVICE_GET_PRIVATE (self); 
    148163 
    149164        if (priv->connect_slot) { 
     
    189204                g_slice_free (ConnectInfo, info); 
    190205        } 
    191  
    192         return; 
    193206} 
    194207 
     
    199212} HandleConnInfo; 
    200213 
    201 static gboolean 
     214static gboolean /* FIXME: this function will always return FALSE, is that correct? */ 
    202215handle_con_idle (gpointer data) 
    203216{ 
    204         HandleConnInfo *info = (HandleConnInfo *) data; 
     217        HandleConnInfo *info; 
     218 
     219        g_return_val_if_fail (data, FALSE); 
     220         
     221        info = (HandleConnInfo *) data; 
    205222        handle_connect (info->self, info->con_err, info->con_state); 
     223 
    206224        return FALSE; 
    207225} 
     
    209227static void  
    210228handle_con_idle_destroy (gpointer data)  
    211 {  
    212         HandleConnInfo *info = (HandleConnInfo *) data; 
    213         g_object_unref (info->self); 
     229
     230        HandleConnInfo *info; 
     231         
     232        g_return_if_fail (data); 
     233         
     234        info = (HandleConnInfo *) data; 
     235 
     236        if (G_IS_OBJECT(info->self)) 
     237                g_object_unref (info->self); 
     238         
    214239        g_slice_free (HandleConnInfo, data);  
    215240} 
     
    219244on_connection_event (ConIcConnection *cnx, ConIcConnectionEvent *event, gpointer user_data) 
    220245{ 
    221         TnyMaemoConicDevice *device = TNY_MAEMO_CONIC_DEVICE (user_data)
    222         TnyMaemoConicDevicePriv *priv = TNY_MAEMO_CONIC_DEVICE_GET_PRIVATE (device)
     246        TnyMaemoConicDevice *device
     247        TnyMaemoConicDevicePriv *priv
    223248        gboolean is_online = FALSE; 
    224249        gboolean emit = FALSE; 
    225250        HandleConnInfo *iinfo; 
    226251        int con_err, con_state; 
     252         
     253        /* we don't need cnx in this function */ 
     254        g_return_if_fail (user_data && TNY_MAEMO_IS_CONIC_DEVICE(user_data)); 
     255        g_return_if_fail (event && CON_IC_IS_CONNECTION_EVENT(event)); 
     256         
     257        device = TNY_MAEMO_CONIC_DEVICE (user_data); 
     258        priv = TNY_MAEMO_CONIC_DEVICE_GET_PRIVATE (device); 
    227259 
    228260        /* Don't emit nor make any changes in case of forced state */ 
     
    252284        switch (con_state) { 
    253285                case CON_IC_STATUS_CONNECTED: 
    254                         if (priv->iap) 
    255                                 g_free (priv->iap); 
     286                        g_free (priv->iap); 
    256287                        priv->iap = g_strdup (con_ic_event_get_iap_id ((ConIcEvent*)(event))); 
    257288                        if (!priv->is_online) 
     
    263294 
    264295                case CON_IC_STATUS_DISCONNECTED: 
     296                        g_free (priv->iap); 
    265297                        priv->iap = NULL; 
    266298                        if (priv->is_online) 
     
    298330        if (emit) 
    299331                conic_emit_status (TNY_DEVICE (device), is_online); 
    300  
    301         return; 
    302332} 
    303333 
     
    337367        info->callback = callback; 
    338368        info->user_data = user_data; 
    339         info->iap_id = g_strdup (iap_id); 
     369        info->iap_id = iap_id ? g_strdup (iap_id) : NULL; /* iap_id can be NULL */ 
    340370 
    341371        priv->connect_slot = info; 
     
    369399                g_slice_free (ConnectInfo, info); 
    370400        } 
    371   
    372         return; 
    373401} 
    374402 
     
    389417        TnyMaemoConicDevicePriv *priv = NULL; 
    390418 
    391         g_return_val_if_fail (TNY_IS_MAEMO_CONIC_DEVICE(self), FALSE); 
     419        g_return_val_if_fail (self && TNY_IS_MAEMO_CONIC_DEVICE(self), FALSE); 
    392420 
    393421        priv = TNY_MAEMO_CONIC_DEVICE_GET_PRIVATE (self); 
     
    449477tny_maemo_conic_device_get_iap (TnyMaemoConicDevice *self, const gchar *iap_id) 
    450478{ 
    451         TnyMaemoConicDevicePriv *priv = NULL
     479        TnyMaemoConicDevicePriv *priv
    452480        g_return_val_if_fail (TNY_IS_MAEMO_CONIC_DEVICE(self), NULL); 
    453481        g_return_val_if_fail (iap_id, NULL); 
     482 
    454483        priv = TNY_MAEMO_CONIC_DEVICE_GET_PRIVATE (self); 
    455484        g_return_val_if_fail (priv->cnx, NULL); 
     
    477506tny_maemo_conic_device_get_iap_list (TnyMaemoConicDevice *self) 
    478507{ 
    479         TnyMaemoConicDevicePriv *priv = NULL; 
     508        TnyMaemoConicDevicePriv *priv; 
     509         
     510        g_return_val_if_fail (TNY_IS_MAEMO_CONIC_DEVICE(self), NULL); 
    480511 
    481512        priv = TNY_MAEMO_CONIC_DEVICE_GET_PRIVATE (self); 
     
    496527tny_maemo_conic_device_free_iap_list (TnyMaemoConicDevice *self, GSList* cnx_list) 
    497528{ 
    498         GSList *cur = cnx_list; 
    499         while (cur) { 
    500                 g_object_unref (G_OBJECT(cur->data)); 
    501                 cur = g_slist_next (cur); 
    502         } 
     529        g_slist_foreach (cnx_list, (GFunc)g_object_unref, NULL); 
    503530        g_slist_free (cnx_list); 
    504         return; 
    505531} 
    506532 
     
    512538        TnyMaemoConicDevicePriv *priv; 
    513539        gboolean already_online = FALSE; 
     540 
    514541        g_return_if_fail (TNY_IS_DEVICE(device)); 
     542 
    515543        self = TNY_MAEMO_CONIC_DEVICE (device); 
    516544        priv = TNY_MAEMO_CONIC_DEVICE_GET_PRIVATE (self); 
    517  
     545         
    518546        already_online = tny_maemo_conic_device_is_online (device); 
    519547 
     
    535563 
    536564        g_return_if_fail (TNY_IS_DEVICE(device)); 
     565 
    537566        self = TNY_MAEMO_CONIC_DEVICE (device); 
    538567        priv = TNY_MAEMO_CONIC_DEVICE_GET_PRIVATE (self); 
     
    545574        if (!already_offline) 
    546575                conic_emit_status (device, FALSE); 
    547  
    548         return; 
    549576} 
    550577 
     
    601628tny_maemo_conic_device_new (void) 
    602629{ 
    603         TnyMaemoConicDevice *self = g_object_new (TNY_TYPE_MAEMO_CONIC_DEVICE, NULL); 
    604  
    605         return TNY_DEVICE (self); 
     630        return TNY_DEVICE(g_object_new (TNY_TYPE_MAEMO_CONIC_DEVICE, NULL)); 
    606631} 
    607632 
     
    609634tny_maemo_conic_device_finalize (GObject *obj) 
    610635{ 
    611         TnyMaemoConicDevicePriv *priv = TNY_MAEMO_CONIC_DEVICE_GET_PRIVATE (obj); 
    612  
     636        TnyMaemoConicDevicePriv *priv; 
     637 
     638        g_return_if_fail (obj && G_IS_OBJECT(obj)); 
     639         
     640        priv = TNY_MAEMO_CONIC_DEVICE_GET_PRIVATE (obj); 
    613641        g_signal_handler_disconnect (obj, priv->signal1); 
    614642