connectionMgr/src/connectScan.c File Reference

connectionMgr - wireless: using scanThread to scan the networks the others: get the networks from registry More...

#include <gtk/gtk.h>
#include <glib.h>
#include <string.h>
#include "connectionMgrLog.h"
#include "scanThread.h"
#include "connectScan.h"
#include "background.h"
#include "erbusy.h"

Detailed Description

connectionMgr - wireless: using scanThread to scan the networks the others: get the networks from registry

Definition in file connectScan.c.

Function Documentation

void connect_scan	(	scanContext_t *	ctxt,
		gboolean	delay
	)

Definition at line 226 of file connectScan.c.

00227 {
00228     scanMode_t   mode;
00229     connection_t type;
00230 
00231     CN_LOGPRINTF("entry");
00232 
00233     g_return_if_fail(ctxt != NULL);
00234     
00235     mode = ctxt->mode;
00236     type = ctxt->networkType;
00237     if ((mode < 0) || (mode >= undefScanMode_e) 
00238         || (type < 0) || (type >= connection_undefined_t))
00239     {
00240         CN_ERRORPRINTF("Invalid arguments: mode[%d] type[%d]", mode, type);
00241         return;
00242     }
00243 
00244     if (ctxt->scanNetworks)
00245     {
00246         CN_WARNPRINTF("Please wait while scanning");
00247         return;
00248     }
00249 
00250     if (delay)
00251     {
00252         if (ctxt->scanTimeoutId > 0)
00253         {
00254             CN_LOGPRINTF("remove the old timeout function for scaning");
00255             g_source_remove(ctxt->scanTimeoutId);
00256             ctxt->scanTimeoutId = 0;
00257         }
00258 
00259         // begin to scan after 5s timeout
00260         if (ctxt->networkType == wireless_t)
00261         {
00262             ctxt->scanTimeoutId = g_timeout_add(200, 
00263                                                 connect_scan_start, 
00264                                                 (gpointer)ctxt);
00265         }
00266         else
00267         {
00268             ctxt->scanTimeoutId = g_timeout_add(5000, 
00269                                                 connect_scan_start, 
00270                                                 (gpointer)ctxt);
00271         }
00272     }
00273     else
00274     {
00275         connect_scan_start((gpointer)ctxt);
00276     }
00277 }

Here is the call graph for this function:

void connect_scan_abort ( scanContext_t * ctxt )

Definition at line 377 of file connectScan.c.

00378 {
00379     CN_LOGPRINTF("entry");
00380 
00381     g_return_if_fail(ctxt != NULL);
00382 
00383     if (ctxt->scanNetworks)
00384     {
00385         CN_WARNPRINTF("Abort scanning...");
00386 
00387         if (ctxt->mode != backgroundScan_e)
00388         {
00389             erbusy_blink();
00390         }
00391 
00392         if (ctxt->networkType == wireless_t)
00393         {
00394             // stop the scan thread
00395             scanThread_stop();
00396 
00397             // wait for scanThread done
00398             ctxt->scanAborting = TRUE;
00399             g_timeout_add(200, delay_connect_scan_abort, (gpointer)ctxt);
00400         }
00401         else
00402         {
00403             // set the flag back to FALSE
00404             ctxt->scanNetworks = FALSE;
00405         }
00406 
00407         if (ctxt->mode != backgroundScan_e)
00408         {
00409             erbusy_off();
00410         }
00411     }
00412 }

Here is the call graph for this function:

void connect_scan_ctxt_destory ( scanContext_t * ctxt )

Definition at line 143 of file connectScan.c.

00144 {
00145     if (ctxt)
00146     {
00147         if (ctxt->scanParms)
00148         {
00149             /*
00150             if (ctxt->scanParms->scanStatus)
00151             {
00152                 gtk_widget_destroy(ctxt->scanParms->scanStatus);
00153             }
00154             */
00155            
00156             if (ctxt->scanParms->ssid)
00157             {
00158                 g_free(ctxt->scanParms->ssid);
00159             }
00160         }
00161 
00162         connect_scan_ctxt_destory_results(ctxt);
00163 
00164         g_free(ctxt->scanParms);
00165         g_free(ctxt);
00166     }
00167 }

Here is the call graph for this function:

static void connect_scan_ctxt_destory_results ( scanContext_t * ctxt ) [static]

Definition at line 169 of file connectScan.c.

00170 {
00171     network_spec_t* networks, *pNetwork;
00172     int i, n;
00173 
00174     if (ctxt && ctxt->scanParms)
00175     {
00176         if (ctxt->scanParms->networks)
00177         {
00178             networks = ctxt->scanParms->networks;
00179             n = ctxt->scanParms->networks_num;
00180 
00181             for (i = 0; i < n; i++)
00182             {
00183                 pNetwork = &networks[i];
00184                 if (pNetwork->ssid)
00185                 {
00186                     g_free(pNetwork->ssid);
00187                 }
00188             }
00189             g_free(ctxt->scanParms->networks);
00190             ctxt->scanParms->networks = NULL;
00191             ctxt->scanParms->networks_num = 0;
00192             ctxt->scanParms->networks_found = 0;
00193         }
00194     }
00195 }

static void connect_scan_ctxt_empty_results ( scanContext_t * ctxt ) [static]

Definition at line 197 of file connectScan.c.

00198 {
00199     network_spec_t* networks, *pNetwork;
00200     int i, n;
00201 
00202     if (ctxt && ctxt->scanParms)
00203     {
00204         if (ctxt->scanParms->networks)
00205         {
00206             networks = ctxt->scanParms->networks;
00207             n = ctxt->scanParms->networks_num;
00208 
00209             for (i = 0; i < n; i++)
00210             {
00211                 pNetwork = &networks[i];
00212                 if (pNetwork->ssid)
00213                 {
00214                     g_free(pNetwork->ssid);
00215                     pNetwork->ssid = NULL;
00216                 }
00217                 pNetwork->encryption = encr_none_t;
00218                 pNetwork->quality = 0;
00219             }
00220 
00221             ctxt->scanParms->networks_found = 0;
00222         }
00223     }
00224 }

scanContext_t* connect_scan_ctxt_new ( void )

Definition at line 49 of file connectScan.c.

00050 {
00051     scanContext_t* ctxt;
00052     GtkWidget* scanStatus;
00053 
00054     ctxt = g_new0(scanContext_t, 1);
00055     g_assert(ctxt != NULL);
00056 
00057     // initilize the scanParams
00058     ctxt->scanParms = g_new0(scan_thread_parms, 1);
00059     g_assert(ctxt->scanParms != NULL);
00060 
00061     scanStatus = gtk_label_new("scan-idle");
00062     g_signal_connect(scanStatus, "notify", 
00063             G_CALLBACK(on_scan_status_changed), ctxt);
00064     ctxt->scanParms->scanStatus = scanStatus;
00065 
00066     // set the default values
00067     connect_scan_ctxt_set_mode(ctxt, undefScanMode_e);
00068     connect_scan_ctxt_set_network_type(ctxt, connection_undefined_t);
00069     connect_scan_ctxt_set_done_callbacks(ctxt, NULL, NULL);
00070 
00071     connect_scan_ctxt_set_ssidlist(ctxt, "");
00072     connect_scan_ctxt_set_max_networks(ctxt, MAX_PROFILES_PER_PAGE);
00073 
00074     // the other values are set to be NULL or zero implicitly by g_new0
00075 
00076     return ctxt;
00077 }

Here is the call graph for this function:

void connect_scan_ctxt_set_done_callbacks	(	scanContext_t *	ctxt,
		scan_done_t *	scan_done,
		scan_done_after_t *	scan_done_after
	)

Definition at line 96 of file connectScan.c.

00099 {
00100     if (ctxt)
00101     {
00102         ctxt->scan_done = scan_done;
00103         ctxt->scan_done_after = scan_done_after;
00104     }
00105 }

void connect_scan_ctxt_set_max_networks	(	scanContext_t *	ctxt,
		int	maxNetworks
	)

Definition at line 119 of file connectScan.c.

00121 {
00122     network_spec_t *networks, *pNetwork;
00123     int             i;
00124 
00125     if (ctxt && ctxt->scanParms && (maxNetworks > 0))
00126     {
00127         // destory the old memory for networks
00128         connect_scan_ctxt_destory_results(ctxt);
00129 
00130         // malloc the new memory for networks
00131         networks = g_new0(network_spec_t, maxNetworks);
00132         g_assert(networks != NULL);
00133         for (i = 0; i < maxNetworks; i++)
00134         {
00135             pNetwork = &networks[i];
00136             pNetwork->encryption = encr_none_t;
00137         }
00138         ctxt->scanParms->networks = networks;
00139         ctxt->scanParms->networks_num = maxNetworks;
00140     }
00141 }

Here is the call graph for this function:

void connect_scan_ctxt_set_mode	(	scanContext_t *	ctxt,
		scanMode_t	mode
	)

Definition at line 79 of file connectScan.c.

00080 {
00081     if (ctxt && (mode >= 0) && (mode < undefScanMode_e))
00082     {
00083         ctxt->mode = mode;
00084     }
00085 }

void connect_scan_ctxt_set_network_type	(	scanContext_t *	ctxt,
		connection_t	networkType
	)

Definition at line 87 of file connectScan.c.

00089 {
00090     if (ctxt && (networkType >= 0) && (networkType < connection_undefined_t))
00091     {
00092         ctxt->networkType = networkType;
00093     }
00094 }

void connect_scan_ctxt_set_ssidlist	(	scanContext_t *	ctxt,
		gchar *	ssidList
	)

Definition at line 107 of file connectScan.c.

00108 {
00109     if (ctxt && ctxt->scanParms && ssidList)
00110     {
00111         if (ctxt->scanParms->ssid)
00112         {
00113             g_free(ctxt->scanParms->ssid);
00114         }
00115         ctxt->scanParms->ssid = g_strdup(ssidList);
00116     }
00117 }

static void connect_scan_done ( scanContext_t * ctxt ) [static]

Definition at line 320 of file connectScan.c.

00321 {
00322     CN_LOGPRINTF("entry");
00323    
00324     g_return_if_fail(ctxt != NULL);
00325 
00326     if (ctxt->scanNetworks)
00327     {
00328         // set the flag back to FALSE
00329         ctxt->scanNetworks = FALSE;
00330 
00331         if (ctxt->scan_done_after)
00332         {
00333             ctxt->scan_done_after();
00334         }
00335 
00336         if (ctxt->mode != backgroundScan_e)
00337         {
00338             erbusy_off();
00339         }
00340     }
00341 }

Here is the call graph for this function:

gboolean connect_scan_freeze_ui ( scanContext_t * ctxt )

Definition at line 343 of file connectScan.c.

00344 {
00345     g_return_val_if_fail(ctxt != NULL, FALSE);
00346 
00347     CN_LOGPRINTF("return freeze = %d", ctxt->scanAborting);
00348     return ctxt->scanAborting;
00349 }

static gboolean connect_scan_start ( gpointer data ) [static]

Definition at line 279 of file connectScan.c.

00280 {
00281     CN_LOGPRINTF("entry");
00282 
00283     scanContext_t* ctxt;
00284 
00285     ctxt = (scanContext_t*)data;
00286     g_return_val_if_fail(ctxt != NULL, FALSE);
00287 
00288     if (ctxt->mode != backgroundScan_e)
00289     {
00290         // busybar begins to blink
00291         erbusy_blink();
00292     }
00293 
00294     // set the flag to be TRUE
00295     ctxt->scanNetworks = TRUE;
00296 
00297     if (ctxt->networkType == wireless_t)
00298     {
00299         // start scanning wireless
00300         wireless_scan_start(ctxt);
00301     }
00302     else
00303     {   
00304         // get the network profiles according to the 'networkType'
00305         if (ctxt->scan_done)
00306         {
00307             ctxt->scan_done(ctxt->networkType, NULL, 0);
00308         }
00309 
00310         // finished scan networks
00311         connect_scan_done(ctxt);
00312     }
00313 
00314     ctxt->scanTimeoutId = 0;
00315     
00316     // don't call me again
00317     return FALSE; 
00318 }

Here is the call graph for this function:

static gboolean delay_connect_scan_abort ( gpointer data ) [static]

Definition at line 351 of file connectScan.c.

00352 {
00353     scanContext_t* ctxt;
00354     gboolean       ret = TRUE;  // TRUE = please call again
00355 
00356     ctxt = (scanContext_t*)data;
00357     g_return_val_if_fail(ctxt != NULL, FALSE);
00358 
00359     // wait the scanThread aborting
00360     if (!scanThread_stopped())
00361     {
00362         CN_LOGPRINTF("call me later...");
00363     }
00364     else
00365     {
00366         ctxt->scanAborting = FALSE;
00367         
00368         // no more scan ongoing
00369         ctxt->scanNetworks = FALSE;
00370 
00371         ret = FALSE;  // FALSE = don't call me again
00372     }
00373 
00374     return ret;
00375 }

Here is the call graph for this function:

static void on_scan_status_changed	(	GObject *	object,
		GParamSpec *	arg,
		gpointer	data
	)			`[static]`

Definition at line 437 of file connectScan.c.

00440 {
00441     CN_LOGPRINTF("entry");
00442 
00443     scanContext_t* ctxt = (scanContext_t*)data;
00444     g_return_if_fail(ctxt != NULL);
00445     
00446     const char *name = arg->name;
00447     g_return_if_fail(strcmp(name,"label") == 0);
00448 
00449     const gchar* scanStatus = gtk_label_get_text(GTK_LABEL(object));
00450     CN_LOGPRINTF("scanStatus [%s]", scanStatus);
00451 
00452     if (strcmp(scanStatus, "scan-done-ok") == 0)
00453     {
00454         if (ctxt->mode != backgroundScan_e)
00455         {
00456             erbusy_off();
00457         }
00458        
00459         gtk_label_set_text(GTK_LABEL(ctxt->scanParms->scanStatus)
00460                 /*GTK_LABEL(object)*/,"scan-idle");
00461         
00462         if (ctxt->scan_done)
00463         {
00464             ctxt->scan_done(wireless_t,
00465                             ctxt->scanParms->networks, 
00466                             ctxt->scanParms->networks_found);
00467         }
00468 
00469         connect_scan_done(ctxt);
00470     }
00471 }

Here is the call graph for this function:

static void wireless_scan_start ( scanContext_t * ctxt ) [static]

Definition at line 414 of file connectScan.c.

00415 {
00416     gboolean ok;
00417 
00418     CN_LOGPRINTF("entry");
00419 
00420     g_return_if_fail(ctxt != NULL);
00421 
00422     // clear old network info
00423     connect_scan_ctxt_empty_results(ctxt);
00424 
00425     CN_LOGPRINTF("Scanning for ssid[%s]", 
00426             ctxt->scanParms ? ctxt->scanParms->ssid : ""); 
00427 
00428     // start scan thread
00429     ok = scanThread_start(ctxt->scanParms);
00430     if (ok && (ctxt->mode != backgroundScan_e))
00431     {
00432         erbusy_blink();
00433     }
00434 }

Here is the call graph for this function:


Functions
static void	connect_scan_ctxt_destory_results (scanContext_t *ctxt)
static void	connect_scan_ctxt_empty_results (scanContext_t *ctxt)
static gboolean	connect_scan_start (gpointer data)
static void	connect_scan_done (scanContext_t *ctxt)
static void	wireless_scan_start (scanContext_t *ctxt)
static void	on_scan_status_changed (GObject object, GParamSpec arg, gpointer data)
scanContext_t *	connect_scan_ctxt_new (void)
void	connect_scan_ctxt_set_mode (scanContext_t *ctxt, scanMode_t mode)
void	connect_scan_ctxt_set_network_type (scanContext_t *ctxt, connection_t networkType)
void	connect_scan_ctxt_set_done_callbacks (scanContext_t ctxt, scan_done_t scan_done, scan_done_after_t *scan_done_after)
void	connect_scan_ctxt_set_ssidlist (scanContext_t ctxt, gchar ssidList)
void	connect_scan_ctxt_set_max_networks (scanContext_t *ctxt, int maxNetworks)
void	connect_scan_ctxt_destory (scanContext_t *ctxt)
void	connect_scan (scanContext_t *ctxt, gboolean delay)
gboolean	connect_scan_freeze_ui (scanContext_t *ctxt)
static gboolean	delay_connect_scan_abort (gpointer data)
void	connect_scan_abort (scanContext_t *ctxt)

connectionMgr/src/connectScan.c File Reference

Functions

Detailed Description

Function Documentation