Riferimenti per la classe org.jaebi.midlet.bt.Discoverer

Diagramma delle classi per org.jaebi.midlet.bt.Discoverer

Inheritance graph
[legenda]
Diagramma di collaborazione per org.jaebi.midlet.bt.Discoverer:

Collaboration graph
[legenda]
Lista di tutti i membri.

Descrizione Dettagliata

Ricerca delle device bluetooth a cui collegarsi e/o servizi di cui usufruire Implementa l'Observable del pattern Observer - Observers.

Il Client (o i Client) che utilizzeranno questa classe, invece, rappresenteranno gli Observer. La notifica ai propri Observer viene inviata ogni qual volta avviene un cambiamento della variabile state; in particolare si distinguono due cambiamenti di stato, a seconda se il cambiamento è dovuto a causa di un errore o meno:

Vedi anche:
org.jaebi.client.midlet.bt.DiscoveryError
TODO quando si fa una chiamata a qualche cancel lo stato dovrebbe passare a READY

Autore:
Antonio

Definizione alla linea 78 del file Discoverer.java.

Membri pubblici

 Discoverer (DiscovererObserver discovererObserver, UUID UUIDset[], int attrset[]) throws BtInitException
 Creates a new instance of Discoverer.
 Discoverer (DiscovererObserver discovererObservers[], UUID UUIDset[], int attrset[]) throws BtInitException
boolean isClosed ()
int getState ()
void run ()
void scanDevicesServices ()
 permette di effettuare una ricerca di device e servizi
void deviceDiscovered (RemoteDevice btDevice, DeviceClass cod)
 Metodo richiamato automaticamente dal sistema quando viene trovata una periferica bluetooth in attesa di connessioni.
void inquiryCompleted (int discType)
 Metodo richiamato dal sistema quando viene completato un inquiry.
void servicesDiscovered (int transID, ServiceRecord[] servRecord)
 Metodo richiamato automaticamente dal sistema quando viene trovato un servizio durante la ricerca dei servizi.
void cancelSearch ()
 Cancel's the devices/services search.
void cancelServiceSearch (int id)
void cancelAllPendigServiceSearch ()
void serviceSearchCompleted (int transID, int respCode)
 Metodo richiamato automaticamente dal sistema quando viene terminata la ricerca dei servizi [vedi commento a searchServices].
DiscoveryReport getDiscoveryReport ()
void destroy ()
 Annulla qualsiasi ricerca di servizi o device richiesta al sistema.
synchronized void addObserver (Observer o)
 Aggiunge un nuovo Observer all'insieme di Observer per questo oggetto, a patto che l'Observer che si sta inserendo non sia già prensente nell'insieme.
synchronized void deleteObserver (Observer o)
 Elimina un Observer dal'insieme.
void notifyObservers ()
 Se l'oggetto è cambiato (hasChanged() ritorna true), notifica tale cambiamento agli obervers effettuando la chiamata al loro metodo update).
void notifyObservers (Object arg)
 Se l'oggetto è cambiato (hasChanged() ritorna true), notifica tale cambiamento agli obervers effettuando la chiamata al loro metodo update.
synchronized void deleteObservers ()
 effettua il clear della lista degli observers
synchronized boolean hasChanged ()
 Verifica se l'oggetto è cambiato.
synchronized int countObservers ()
 Ritorna il numero di observer per questo oggetto.

Attributi pubblici statici

static final int READY = 0
 Indica che non ci sono nè ricerche di servizi nè ricerche di device in pending.
static final int DEVICE_SEARCH = 1
 Indica che il discoverer è in cerca di device bluettoth a cui collegarsi.
static final int DISCOVERY_ERROR = 2
 Indica che è avvenuto un errore che rende impossibile continuare le attività di ricerca.
static final int SERVICE_SEARCH = 3
 Indica che il discoverer è in cerca di servizi.
static final int NEW_SERVICE_SEARCH_ERROR = 4
 Indica che è avvenuto un errore durante la ricerca dei servizi disponibili.
static final int NEW_SERVICE_SEARCH_COMPLETE = 5
 Indica che una delle ricerche di servizi sottomessa è stata completata.

Membri protetti

synchronized void setChanged ()
 Marca questo oggetto Observable come changed.
synchronized void clearChanged ()
 Indica che gli observer sono stati notificati dell'ultimo cambiamento.

Attributi con visibilità di package

LocalDevice localDevice

Membri privati

void setState (int state)
synchronized void searchDevices () throws StartInquiryException, DiscoveryInterruptionException, InquiryErrorException, UnexpectedDiscoveryCodeException
 Ricerca nuove device bluetooth a cui collegarsi (effettua, in pratica, lo start dell'inquiry).
synchronized void searchServices () throws DiscoveryInterruptionException
 E' da notare che, differentemente da quanto accade all'interno di searchDevice(), lo switch sul respCode ritornato dalla ricerca dei servizi viene fatto direttamente all'interno dell'handler serviceSearchCompleted().

Attributi privati

DiscoveryAgent discoveryAgent
int state = READY
 tiene traccia dello stato corrente del discoverer.
DiscoveryReport discoveryReport
 tiene traccia delle device trovate durante l'inquiry e, per ogni device, dei servizi che offre
Hashtable serviceSearches
 Ogni qual volta si inizia una ricerca dei servizi disponibili su una determinata device, il sistema associa un id a tale richiesta.
int discType
 tiene traccia del codice ritornato dalla ricerca delle device
boolean closed
UUID UUIDset []
 insieme degli UUID che un servizio deve avere per essere ritrovato da questo discoverer
int attrset []
 insieme di attributi che un servizio deve avere per essere ritrovato da questo discoverer


Documentazione dei costruttori e dei distruttori

org.jaebi.midlet.bt.Discoverer.Discoverer DiscovererObserver  discovererObserver,
UUID  UUIDset[],
int  attrset[]
throws BtInitException
 

Creates a new instance of Discoverer.

Definizione alla linea 131 del file Discoverer.java.

Riferimenti org.jaebi.midlet.bt.Discoverer.attrset, org.jaebi.midlet.bt.Discoverer.closed, org.jaebi.midlet.bt.Discoverer.discoveryAgent, org.jaebi.midlet.bt.Discoverer.localDevice, e org.jaebi.midlet.bt.Discoverer.UUIDset.

00131                                                                                                                    {
00132         closed = false;
00133         this.discoveryReport = new DiscoveryReport();
00134         
00135         try{
00136             // crea/ottiene un localDevice e un discovery agent
00137             localDevice = LocalDevice.getLocalDevice();
00138             discoveryAgent = localDevice.getDiscoveryAgent();
00139         }catch (BluetoothStateException e1) {
00140             throw new BtInitException("Impossibile inizializzare la periferica bluetooth");
00141         }
00142         this.addObserver((Observer)discovererObserver);
00143         this.UUIDset = UUIDset;
00144         this.attrset = attrset;
00145     }

org.jaebi.midlet.bt.Discoverer.Discoverer DiscovererObserver  discovererObservers[],
UUID  UUIDset[],
int  attrset[]
throws BtInitException
 

Definizione alla linea 147 del file Discoverer.java.

Riferimenti org.jaebi.midlet.bt.Discoverer.attrset, org.jaebi.midlet.bt.Discoverer.closed, org.jaebi.midlet.bt.Discoverer.discoveryAgent, org.jaebi.midlet.bt.Discoverer.localDevice, e org.jaebi.midlet.bt.Discoverer.UUIDset.

00147                                                                                                                     {
00148         closed = false;
00149         this.discoveryReport = new DiscoveryReport();
00150         
00151         try{
00152             // crea/ottiene un localDevice e un discovery agent
00153             localDevice = LocalDevice.getLocalDevice();
00154             discoveryAgent = localDevice.getDiscoveryAgent();
00155         }catch (BluetoothStateException e1) {
00156             throw new BtInitException("Impossibile inizializzare la periferica bluetooth");
00157         }
00158         
00159         for (int i =0; i<discovererObservers.length; i++){
00160             this.addObserver((Observer)discovererObservers[i]);
00161         }
00162         this.UUIDset = UUIDset;
00163         this.attrset = attrset;
00164     }


Documentazione delle funzioni membro

synchronized void org.jaebi.midlet.util.Observable.addObserver Observer  o  )  [inherited]
 

Aggiunge un nuovo Observer all'insieme di Observer per questo oggetto, a patto che l'Observer che si sta inserendo non sia già prensente nell'insieme.

Il metodo è dichiarato synchronized per evitare che, nel caso di multithreading, si verifichino race conditions che portino ad inserire ugualmente due volte lo stesso Observer

Parametri:
o an observer to be added.
Eccezioni:
NullPointerException if the parameter o is null.

Definizione alla linea 39 del file Observable.java.

Riferimenti org.jaebi.midlet.util.Observable.obs.

00039                                                      {
00040         if (o == null)
00041             throw new NullPointerException();
00042         if (!obs.contains(o)) {
00043             obs.addElement(o);
00044         }
00045     }

void org.jaebi.midlet.bt.Discoverer.cancelAllPendigServiceSearch  ) 
 

Definizione alla linea 522 del file Discoverer.java.

Riferimenti org.jaebi.midlet.bt.Discoverer.discoveryAgent, e org.jaebi.midlet.bt.Discoverer.serviceSearches.

00522                                               {
00523         Enumeration en = serviceSearches.keys();
00524         
00525         while (en.hasMoreElements()){
00526             int id = ((Integer)en.nextElement()).intValue();
00527             discoveryAgent.cancelServiceSearch(id);
00528         }
00529     }

void org.jaebi.midlet.bt.Discoverer.cancelSearch  ) 
 

Cancel's the devices/services search.

Definizione alla linea 500 del file Discoverer.java.

Riferimenti org.jaebi.midlet.bt.DiscovererState.DEVICE_SEARCH, org.jaebi.midlet.bt.Discoverer.discoveryAgent, org.jaebi.midlet.bt.DiscovererState.SERVICE_SEARCH, org.jaebi.midlet.bt.Discoverer.serviceSearches, e org.jaebi.midlet.bt.Discoverer.state.

Referenziato da org.jaebi.midlet.bt.Discoverer.destroy().

00500                                {
00501         synchronized (this) {
00502             if (state == DEVICE_SEARCH) {
00503                 discoveryAgent.cancelInquiry(this);
00504             } else if (state == SERVICE_SEARCH) {
00505                 Enumeration en = serviceSearches.keys();
00506                 while (en.hasMoreElements()){
00507                     int id = ((Integer)en.nextElement()).intValue();
00508                     discoveryAgent.cancelServiceSearch(id);
00509                 }
00510             }
00511         }
00512     }

void org.jaebi.midlet.bt.Discoverer.cancelServiceSearch int  id  ) 
 

Definizione alla linea 516 del file Discoverer.java.

Riferimenti org.jaebi.midlet.bt.Discoverer.discoveryAgent.

00516                                            {
00517         discoveryAgent.cancelServiceSearch(id);
00518     }

synchronized void org.jaebi.midlet.util.Observable.clearChanged  )  [protected, inherited]
 

Indica che gli observer sono stati notificati dell'ultimo cambiamento.

il metodo hasChanged ora ritornerà false. Questo metodo è chiamato automaticamente dal metodo notifyObservers.

Vedi anche:
org.jaebi.client.midlet.util.Observable.notifyObservers()

org.jaebi.client.midlet.util.Observable.notifyObservers(java.lang.Object)

Definizione alla linea 136 del file Observable.java.

Riferimenti org.jaebi.midlet.util.Observable.changed.

Referenziato da org.jaebi.midlet.util.Observable.notifyObservers().

00136                                                {
00137         changed = false;
00138     }

synchronized int org.jaebi.midlet.util.Observable.countObservers  )  [inherited]
 

Ritorna il numero di observer per questo oggetto.

Restituisce:
il numero di observer per questo oggetto.

Definizione alla linea 159 del file Observable.java.

Riferimenti org.jaebi.midlet.util.Observable.obs.

00159                                              {
00160         return obs.size();
00161     }

synchronized void org.jaebi.midlet.util.Observable.deleteObserver Observer  o  )  [inherited]
 

Elimina un Observer dal'insieme.

Parametri:
o the observer to be deleted.

Definizione alla linea 52 del file Observable.java.

Riferimenti org.jaebi.midlet.util.Observable.obs.

00052                                                         {
00053         obs.removeElement(o);
00054     }

synchronized void org.jaebi.midlet.util.Observable.deleteObservers  )  [inherited]
 

effettua il clear della lista degli observers

Definizione alla linea 116 del file Observable.java.

Riferimenti org.jaebi.midlet.util.Observable.obs.

00116                                                {
00117         obs.removeAllElements();
00118     }

void org.jaebi.midlet.bt.Discoverer.destroy  ) 
 

Annulla qualsiasi ricerca di servizi o device richiesta al sistema.

Definizione alla linea 678 del file Discoverer.java.

Riferimenti org.jaebi.midlet.bt.Discoverer.cancelSearch(), e org.jaebi.midlet.bt.Discoverer.closed.

Referenziato da org.jaebi.midlet.bt.BtClient.cancelDiscovery(), e org.jaebi.midlet.bt.Discoverer.searchDevices().

00678                          {
00679         /* risveglio l'eventuale thread in attesa che la scansione delle device
00680          * o dei servizi termini
00681          */
00682         notify();
00683         cancelSearch();
00684         closed = true;
00685         //TODO implementami!!
00686     }

Questo è il grafo delle chiamate per questa funzione:

void org.jaebi.midlet.bt.Discoverer.deviceDiscovered RemoteDevice  btDevice,
DeviceClass  cod
 

Metodo richiamato automaticamente dal sistema quando viene trovata una periferica bluetooth in attesa di connessioni.

Definizione alla linea 452 del file Discoverer.java.

Riferimenti org.jaebi.midlet.bt.discoveryHandling.DiscoveryReport.addDevice(), e org.jaebi.midlet.bt.Discoverer.discoveryReport.

00453                             {
00454         
00455         discoveryReport.addDevice(btDevice);
00456         
00457         //TODO debug
00458         System.out.println("device trovata: " + btDevice.getBluetoothAddress());
00459     }

Questo è il grafo delle chiamate per questa funzione:

DiscoveryReport org.jaebi.midlet.bt.Discoverer.getDiscoveryReport  ) 
 

Definizione alla linea 670 del file Discoverer.java.

Riferimenti org.jaebi.midlet.bt.Discoverer.discoveryReport.

Referenziato da org.jaebi.midlet.bt.DiscovererObserver.update().

00670                                                {
00671         return discoveryReport;
00672     }

int org.jaebi.midlet.bt.Discoverer.getState  ) 
 

Implementa org.jaebi.midlet.bt.DiscovererState.

Definizione alla linea 172 del file Discoverer.java.

Referenziato da org.jaebi.midlet.bt.DiscovererObserver.update().

00172                          {
00173         return this.state;
00174     }

synchronized boolean org.jaebi.midlet.util.Observable.hasChanged  )  [inherited]
 

Verifica se l'oggetto è cambiato.

Restituisce:
true se e solo se il metodo setChanged è stato chiamato più recetemente di quando è stato chiamato clearChanged su quest'oggetto; false altrimenti.
Vedi anche:
org.jaebi.client.midlet.util.Observable.clearChanged()

org.jaebi.client.midlet.util.Observable.setChanged()

Definizione alla linea 150 del file Observable.java.

Riferimenti org.jaebi.midlet.util.Observable.changed.

00150                                              {
00151         return changed;
00152     }

void org.jaebi.midlet.bt.Discoverer.inquiryCompleted int  discType  ) 
 

Metodo richiamato dal sistema quando viene completato un inquiry.

Definizione alla linea 465 del file Discoverer.java.

00465                                               {
00466         
00467         /*
00468          * Ricopio il discType ritornato dal sistema nell'opportuna var di
00469          * istanza
00470          */
00471         this.discType = discType;
00472         
00473         /* risveglio il thread (lanciato da scanDevicesServices()) che era in
00474          * attesa del completamento dell'inquiry
00475          */
00476         //TODO capire perchè è una reg critica
00477         synchronized (this) {
00478             notify();
00479         }
00480     }

boolean org.jaebi.midlet.bt.Discoverer.isClosed  ) 
 

Definizione alla linea 167 del file Discoverer.java.

Referenziato da org.jaebi.midlet.bt.Discoverer.searchDevices(), e org.jaebi.midlet.bt.Discoverer.searchServices().

00167                              {
00168         return this.closed;
00169     }

void org.jaebi.midlet.util.Observable.notifyObservers Object  arg  )  [inherited]
 

Se l'oggetto è cambiato (hasChanged() ritorna true), notifica tale cambiamento agli obervers effettuando la chiamata al loro metodo update.

Una volta effettuata la notifica, viene chiamato il metodo clearChanged per indicare che l'oggetto non è più cambiato dall'ultima notifica.

Parametri:
arg any object.
Vedi anche:
org.jaebi.client.midlet.util.Observable.clearChanged()

org.jaebi.client.midlet.util.Observable.hasChanged()

org.jaebi.client.midlet.util.Observer.update(java.util.Observable, java.lang.Object)

Definizione alla linea 80 del file Observable.java.

Riferimenti org.jaebi.midlet.util.Observable.changed, org.jaebi.midlet.util.Observable.clearChanged(), e org.jaebi.midlet.util.Observable.obs.

00080                                             {
00081         /*
00082          *Collezione degli observer usata come snapshot dello stato degli observer correnti
00083          */
00084         Enumeration observers;
00085         
00086         synchronized (this) {
00087             /*
00088              * Il codice incaricato di estrarre la lista degli observer da notificare
00089              * necessita di sincronizzazione ma la notifica vera e propria no (non dovrebbe)
00090              * Il peggior risultato di una qualsiasi race-condition che possa verificarsi qui (in assenza di sincronizzazione
00091              *  è il seguente:
00092              * 1) a newly-added Observer will miss a
00093              *   notification in progress: siccome anche il metododo addObserver() è
00094              *   dichiarato sinchronized non può verificarsi che un flusso di controllo aggiunga un nuovo observer
00095              *   mentre un altro sta recuperando la lista degli observer per effettuare la notifica
00096              * 2) a recently unregistered Observer will be
00097              *   wrongly notified when it doesn't care: non può verificarsi che un flusso di controllo
00098              *   stia rimuovendo un observer mentre un altro sta recuperando
00099              *   la lista delgi observer a cui inviare la notifica (il metodo deleteObserver() è dichiarato anch'esso
00100              *   synchronized
00101              */
00102             if (!changed)
00103                 return;
00104             observers = obs.elements();
00105             clearChanged();
00106         }
00107         
00108         while (observers.hasMoreElements())
00109             ((Observer)observers.nextElement()).update(this, arg);
00110            
00111     }

Questo è il grafo delle chiamate per questa funzione:

void org.jaebi.midlet.util.Observable.notifyObservers  )  [inherited]
 

Se l'oggetto è cambiato (hasChanged() ritorna true), notifica tale cambiamento agli obervers effettuando la chiamata al loro metodo update).

Una volta effettuata la notifica, viene chiamato il metodo clearChanged per indicare che l'oggetto non è più cambiato dall'ultima notifica.

Vedi anche:
org.jaebi.client.midlet.util.Observable.clearChanged()

org.jaebi.client.midlet.util.Observable.hasChanged()

org.jaebi.client.midlet.util.Observer.update(java.util.Observable, java.lang.Object)

Definizione alla linea 65 del file Observable.java.

Referenziato da org.jaebi.midlet.bt.ConnectionSet.addConnection(), org.jaebi.midlet.bt.ConnectionSet.removeConnection(), org.jaebi.midlet.bt.Discoverer.run(), org.jaebi.midlet.bt.Discoverer.searchServices(), e org.jaebi.midlet.bt.Discoverer.serviceSearchCompleted().

00065                                   {
00066         notifyObservers(null);
00067     }

void org.jaebi.midlet.bt.Discoverer.run  ) 
 

se si è verificato errore o se non è stata trovata alcuna periferica, è inutile continuare

Definizione alla linea 323 del file Discoverer.java.

Riferimenti org.jaebi.midlet.bt.discoveryHandling.DiscoveryReport.clear(), org.jaebi.midlet.bt.DiscovererState.DEVICE_SEARCH, org.jaebi.midlet.bt.discoveryHandling.DiscoveryReport.deviceCount(), org.jaebi.midlet.bt.Discoverer.discoveryReport, org.jaebi.midlet.util.Observable.notifyObservers(), org.jaebi.midlet.bt.DiscovererState.READY, org.jaebi.midlet.bt.Discoverer.searchDevices(), org.jaebi.midlet.bt.Discoverer.searchServices(), org.jaebi.midlet.bt.DiscovererState.SERVICE_SEARCH, e org.jaebi.midlet.bt.Discoverer.setState().

00323                      {
00324         discoveryReport.clear();
00325         DiscoveryError discoveryError = null;
00326         
00327         /*_____________________________________________________________________
00328          * comincio la scansione delle device
00329          * in caso di errore, istanzio opportunamente deviceError e chiamo
00330          * setChanged per la notifica agli observer
00331          *_____________________________________________________________________
00332          */
00333         setState(DEVICE_SEARCH);
00334         notifyObservers();
00335         //TODO nei catch di qui sotto deve andare un return (che continuo a fare se la ricerca delle device ha dato errore?
00336         //TODO nei casi di errori gravi, svuotare discoveryreport
00337         try{
00338             searchDevices();
00339         }
00340         
00341         catch(StartInquiryException e){
00342             discoveryError = new DeviceSearchError(DeviceSearchError.CANT_START_INQUIRY, e.getMessage());
00343         }
00344         
00345         catch (DiscoveryInterruptionException e1){
00346             
00347             /***********************************************************
00348              * l'inquiry è stato interrotto; sono 3 le possibili cause:
00349              ***********************************************************/
00350             
00351             String errorMsg = e1.getMessage();
00352             Exception ex;
00353             
00354             try{
00355                 
00356                 /*************************************************
00357                  * 1) è stata fatta una chiamata a cancelSearch()
00358                  *************************************************/
00359                 
00360                 ex =(UserInterruptionException)e1;
00361                 discoveryError = new DeviceSearchError(DeviceSearchError.INQUIRY_TERMINATED, errorMsg);
00362             } catch (ClassCastException ex1){
00363                 
00364                 try{
00365                     
00366                     /**************************************************
00367                      * 2) la wait ha lanciato un InterruptedException
00368                      **************************************************/
00369                     
00370                     ex = (UnexpectedInterruptionException)e1;
00371                     discoveryError = new DiscoveryError(DeviceSearchError.UNEXPECTED_DISCOVERY_INTERRUPTION, errorMsg);
00372                 } catch (ClassCastException ex2){
00373                     
00374                     /******************************************
00375                      * 3) è stata fatta una chiamata a destroy()
00376                      ******************************************/
00377                     
00378                     discoveryError = new DiscoveryError(DeviceSearchError.DISCOVERY_INTERRUPTION, errorMsg);
00379                 }
00380                 
00381             }
00382             
00383         }
00384         
00385         catch (InquiryErrorException e2){
00386             discoveryError = new DeviceSearchError(DeviceSearchError.INQUIRY_ERROR, e2.getMessage());
00387         }
00388         
00389         catch(UnexpectedDiscoveryCodeException e3){
00390             discoveryError = new DiscoveryError(DeviceSearchError.UNKNOWN_DISCOVERY_CODE, e3.getMessage());
00391         }
00392         
00393         notifyObservers(discoveryError);
00394         
00398         if( (discoveryError != null) || (discoveryReport.deviceCount()==0) ){
00399             setState(READY);
00400             notifyObservers();
00401             return;
00402         }
00403         
00404         /*______________________________________________________________________
00405          * Comincio la scansione dei servizi
00406          *______________________________________________________________________
00407          */
00408         setState(SERVICE_SEARCH);
00409         
00410         /*
00411          * notifico agli observer che lo stato del discoverer è cambiato ed
00412          * invio loro la lista delle devices trovate
00413          */
00414         notifyObservers();
00415         
00416         try{
00417             searchServices();
00418         }
00419         
00420         catch (DiscoveryInterruptionException e) {
00421             Exception ex;
00422             String errorMsg = e.getMessage();
00423             try{
00424                 ex = (UnexpectedInterruptionException)e;
00425                 discoveryError = new DiscoveryError(DiscoveryError.UNEXPECTED_DISCOVERY_INTERRUPTION, errorMsg);
00426             } catch (ClassCastException e1){
00427                 discoveryError = new DiscoveryError(DiscoveryError.DISCOVERY_INTERRUPTION, errorMsg);
00428             }
00429         }
00430         
00431         notifyObservers(discoveryError);
00432         
00433         setState(READY);
00434         notifyObservers();
00435         
00436     }

Questo è il grafo delle chiamate per questa funzione:

void org.jaebi.midlet.bt.Discoverer.scanDevicesServices  ) 
 

permette di effettuare una ricerca di device e servizi

Definizione alla linea 442 del file Discoverer.java.

Riferimenti org.jaebi.midlet.bt.Discoverer.closed.

Referenziato da org.jaebi.midlet.bt.BtClient.startDiscovery().

00442                                      {
00443         closed = false;
00444         new Thread(this).start();
00445     }

synchronized void org.jaebi.midlet.bt.Discoverer.searchDevices  )  throws StartInquiryException, DiscoveryInterruptionException, InquiryErrorException, UnexpectedDiscoveryCodeException [private]
 

Ricerca nuove device bluetooth a cui collegarsi (effettua, in pratica, lo start dell'inquiry).

Il metodo è dichiarato synchronized per evitare che più di un flusso di controllo effettui concorrentemente la ricerca delle device

Definizione alla linea 189 del file Discoverer.java.

Riferimenti org.jaebi.midlet.bt.Discoverer.destroy(), org.jaebi.midlet.bt.DiscovererState.DISCOVERY_ERROR, org.jaebi.midlet.bt.Discoverer.discoveryAgent, org.jaebi.midlet.bt.Discoverer.discType, org.jaebi.midlet.bt.Discoverer.isClosed(), e org.jaebi.midlet.bt.Discoverer.setState().

Referenziato da org.jaebi.midlet.bt.Discoverer.run().

00189                                                                                                                                                                    {
00190         
00191         try {
00192             discoveryAgent.startInquiry(DiscoveryAgent.GIAC, this);
00193         } catch (BluetoothStateException e) {
00194             setState(DISCOVERY_ERROR);
00195             throw new StartInquiryException("Impossibile iniziare l'inquiry; impossibile iniziare la ricerca di device");
00196         }
00197         
00198         try {
00199             // sospendo il thread finchè non viene terminata la ricerca delle device (cioè finchè il sistema non effettua la chiamata a inquiryCompleted()
00200             wait();
00201         } catch (InterruptedException e) {
00202             setState(DISCOVERY_ERROR);
00203             throw new UnexpectedInterruptionException("Ricerca device terminata a causa di un'interruzione inaspettata");
00204         }
00205         
00206         // il thread è stato risvegliato per una chiamata a destroy()?
00207         if (isClosed()) {
00208             setState(DISCOVERY_ERROR);
00209             throw new DiscoveryInterruptionException("Discovery interrotto");
00210         }
00211         
00212         /* no? Allora a questo punto il sistema ha terminato l'inquiry, avrà invocato
00213          * inquiryCompleted() che a sua volta avrà ricopiato il codice di
00214          * ritorno nella var di istanza discType
00215          */
00216         switch (discType) {
00217             case INQUIRY_ERROR:
00218                 setState(DISCOVERY_ERROR);
00219                 throw new InquiryErrorException("errore durante la ricerca di device");
00220             case INQUIRY_TERMINATED:
00221                 
00222                 /*
00223                  * Se si è arrivati qui, significa che è stata fatta una chiamata
00224                  * a cancelSearch()
00225                  */
00226                 setState(DISCOVERY_ERROR);
00227                 throw new UserInterruptionException("Ricerca delle device interrotta");
00228                 
00229             case INQUIRY_COMPLETED:
00230                 
00231                 break;
00232             default:
00233                 setState(DISCOVERY_ERROR);
00234                 //discType sconosciuto
00235                 destroy();
00236                 throw new UnexpectedDiscoveryCodeException("Errore di sistema: discovery code sconosciuto");
00237         }
00238     }

Questo è il grafo delle chiamate per questa funzione:

synchronized void org.jaebi.midlet.bt.Discoverer.searchServices  )  throws DiscoveryInterruptionException [private]
 

E' da notare che, differentemente da quanto accade all'interno di searchDevice(), lo switch sul respCode ritornato dalla ricerca dei servizi viene fatto direttamente all'interno dell'handler serviceSearchCompleted().

Questo perchè ho interesse che gli observer siano informati in tempo reale dell'esito della ricerca su una determinata device. Siccome, nel nostro caso, il thread che invoca searchServices si mette in attesa finchè tutte le ricerche di servizi non vengano completate, se si effettuava il controllo qui si potevano informare gli observer solo alla fine di tutte le ricerche, non ogni qual volta ne terminasse una

Ricerco i servizi disponibili sulle device trovate attraverso l'inquiry. Invio una richiesta di ricerca per ogni device trovata. Tutte le ricerche avvengono concorrenzialmente

Non faccio lanciare alcuna eccezione perchè se su una device non è possibile ricercare i servizi disponibili, voglio che la ricerca continui per le altre device

Definizione alla linea 252 del file Discoverer.java.

Riferimenti org.jaebi.midlet.bt.Discoverer.attrset, org.jaebi.midlet.bt.DiscovererState.DISCOVERY_ERROR, org.jaebi.midlet.bt.Discoverer.discoveryAgent, org.jaebi.midlet.bt.Discoverer.discoveryReport, org.jaebi.midlet.bt.discoveryHandling.DiscoveryReport.getDevices(), org.jaebi.midlet.bt.Discoverer.isClosed(), org.jaebi.midlet.bt.Discoverer.localDevice, org.jaebi.midlet.bt.DiscovererState.NEW_SERVICE_SEARCH_ERROR, org.jaebi.midlet.util.Observable.notifyObservers(), org.jaebi.midlet.bt.DiscovererState.SERVICE_SEARCH, org.jaebi.midlet.bt.Discoverer.serviceSearches, org.jaebi.midlet.bt.Discoverer.setState(), e org.jaebi.midlet.bt.Discoverer.UUIDset.

Referenziato da org.jaebi.midlet.bt.Discoverer.run().

00252                                                                                     {
00253         serviceSearches = new Hashtable();
00254         Enumeration devices = discoveryReport.getDevices();
00255         DiscoveryError discoveryError = null;
00256         
00257         //TODO debug
00258         System.out.println("sono il client e sto cercando questi UUID");
00259         for (int i=0; i<UUIDset.length; i++)
00260             System.out.println(UUIDset[i]);
00261         System.out.println("sono il client e sto cercando questi attr");
00262         for (int i=0; i<attrset.length; i++)
00263             System.out.println(attrset[i]);
00264         //fine debug
00265         
00271         while (devices.hasMoreElements()) {
00272             RemoteDevice rd = (RemoteDevice) devices.nextElement();
00273             //TODO debug
00274             System.out.println("sono il client ed ho indirizzo " + localDevice.getBluetoothAddress() );
00275             System.out.println("sono il client ed ho trovato un server con indirizzo " + rd.getBluetoothAddress() );
00276             
00277             try {
00278                 int id = discoveryAgent.searchServices(null, UUIDset,rd, this);
00279                 serviceSearches.put(new Integer(id), rd );
00280             } catch (BluetoothStateException e) {
00286                 
00287                 String errorMsg = "Impossibile ricercare i servizi offerti dalla device ";
00288                 
00289                 discoveryError = new ServiceSearchError(ServiceSearchError.CANT_START_SEARCH, errorMsg, rd);
00290                 setState(NEW_SERVICE_SEARCH_ERROR);
00291                 notifyObservers(discoveryError);
00292                 setState(SERVICE_SEARCH);
00293                 notifyObservers();
00294             }
00295             
00296             try {
00297                 /*
00298                  * sospendo il thread finchè tutte le ricerche di servizi non
00299                  * siano terminate
00300                  */
00301                 wait();
00302             } catch (InterruptedException e) {
00303                 setState(DISCOVERY_ERROR);
00304                 throw new UnexpectedInterruptionException("Ricerca servizi terminata a causa di un'interruzione inaspettata");
00305             }
00306             
00307             // il thread è stato risvegliato per una chiamata a destroy()?
00308             if (isClosed()) {
00309                 setState(DISCOVERY_ERROR);
00310                 throw new DiscoveryInterruptionException("Discovery interrotto");
00311             }
00312             
00313              /* no? Allora a questo punto il sistema ha terminato la ricerca,
00314               * avrà invocato ServiceSearchCompleted() -in particolare avrà
00315               * fatto tante chiamate a questo metodo quante sono le ricerche di
00316               * servizi richieste- che a sua volta avrà opportunamente "riempito"
00317               * respCode
00318               */
00319         }
00320     }

Questo è il grafo delle chiamate per questa funzione:

void org.jaebi.midlet.bt.Discoverer.servicesDiscovered int  transID,
ServiceRecord[]  servRecord
 

Metodo richiamato automaticamente dal sistema quando viene trovato un servizio durante la ricerca dei servizi.

Definizione alla linea 487 del file Discoverer.java.

Riferimenti org.jaebi.midlet.bt.discoveryHandling.DiscoveryReport.addService(), e org.jaebi.midlet.bt.Discoverer.discoveryReport.

00487                                                                           {
00488         //TODO debug
00489         System.out.println("servizio scoperto");
00490         
00491         for (int i = 0; i < servRecord.length; i++) {
00492             discoveryReport.addService(servRecord[i]);
00493             
00494         }
00495     }

Questo è il grafo delle chiamate per questa funzione:

void org.jaebi.midlet.bt.Discoverer.serviceSearchCompleted int  transID,
int  respCode
 

Metodo richiamato automaticamente dal sistema quando viene terminata la ricerca dei servizi [vedi commento a searchServices].

notifico gli observer circa il nuovo stato del discoverer; Se la ricerca ha prodotto qualche errore, invio loro un'istanza di ServiceSearchError, altrimenti l'argomento di notifyObservers sarà null

Definizione alla linea 536 del file Discoverer.java.

Riferimenti org.jaebi.midlet.bt.Discoverer.discoveryReport, org.jaebi.midlet.bt.discoveryHandling.DiscoveryReport.getServices(), org.jaebi.midlet.bt.DiscovererState.NEW_SERVICE_SEARCH_COMPLETE, org.jaebi.midlet.bt.DiscovererState.NEW_SERVICE_SEARCH_ERROR, org.jaebi.midlet.util.Observable.notifyObservers(), org.jaebi.midlet.bt.DiscovererState.SERVICE_SEARCH, org.jaebi.midlet.bt.Discoverer.serviceSearches, e org.jaebi.midlet.bt.Discoverer.setState().

00536                                                                  {
00537         boolean error = false;
00538         String errorMsg;
00539         
00540         /*
00541          * Recupero la device su cui è stata sottomessa la ricerca con
00542          * id = transid
00543          */
00544         Integer id = new Integer(transID);
00545         RemoteDevice rd = (RemoteDevice) serviceSearches.get(id);
00546         
00547         //TODO debug
00548         if (rd != null){
00549             System.out.println("è finita la ricerca di servizi per la device con indirizzo " + rd.getBluetoothAddress());
00550             System.out.println("ci sono " + discoveryReport.getServices(rd).size()+" servizi associati a questa device");
00551         } else
00552             System.out.println("trans id inatteso");
00553         
00554         DiscoveryError discoveryError = null;
00555         
00556         
00557         if (!serviceSearches.containsKey(id)) {
00558             /*******************************************************************
00559              * error - l'id della ricerca appena terminata non era tra gli id
00560              * delle nostre richieste
00561              ******************************************************************/
00562             
00563             error = true;
00564             errorMsg = "Id ricerca non previsto";
00565             setState(NEW_SERVICE_SEARCH_ERROR);
00566             discoveryError = new ServiceSearchError(ServiceSearchError.UNEXPECTED_TRANS_ID, errorMsg, rd);
00567             
00568             // TODO devo far fare qualcos'altro?
00569         }
00570         
00571         //aggiorno la lista delle ricerche in pending
00572         this.serviceSearches.remove(id);
00573         
00574         
00575         /*
00576          * se l'id della ricerca terminata non è tra quelle pending, è inutile
00577          * che controllo il suo respCode
00578          */
00579         if (!error){
00580             switch (respCode){
00581                 
00582                 case SERVICE_SEARCH_ERROR:
00583                     setState(NEW_SERVICE_SEARCH_ERROR);
00584                     errorMsg = "Errore durante la ricerca di servizi";
00585                     discoveryError = new ServiceSearchError(ServiceSearchError.SEARCH_ERROR, errorMsg, rd);
00586                     break;
00587                     
00588                 case SERVICE_SEARCH_TERMINATED:
00589                 /*
00590                  * Se si è arrivati qui, significa che è stata fatta una chiamata
00591                  * a cancelServiceSearch() o cancelAllPendingSrviceSearch
00592                  */
00593                     setState(NEW_SERVICE_SEARCH_ERROR);
00594                     errorMsg = "Ricerca dei servizi interrotta";
00595                     discoveryError = new ServiceSearchError(ServiceSearchError.SEARCH_TERMINATED, errorMsg, rd);
00596                     break;
00597                     
00598                 case SERVICE_SEARCH_COMPLETED:
00599                     setState(this.NEW_SERVICE_SEARCH_COMPLETE);
00600                     
00601                     /* chiamo un notifyObservers perchè voglio che sia inviato
00602                      * loro la device su cui è terminata la ricerca così poi attravesro
00603                      *observable recupero i servizxi
00604                      */
00605                     //TODO perchè mi da class cast exception???
00606                     notifyObservers(rd);
00607                     break;
00608                     
00609                 case SERVICE_SEARCH_NO_RECORDS:
00610                     setState(NEW_SERVICE_SEARCH_ERROR);
00611                     errorMsg = "Per questa device non è stato trovato alcun record di servizio compatibile con quelli richiesti";
00612                     discoveryError = new ServiceSearchError(ServiceSearchError.SEARCH_TERMINATED, errorMsg, rd);
00613                     break;
00614                     
00615                 case SERVICE_SEARCH_DEVICE_NOT_REACHABLE:
00616                     setState(NEW_SERVICE_SEARCH_ERROR);
00617                     errorMsg = "Per questa device non è possibile continuare la ricerca di servizi perchè la device risulta non raggiungibile";
00618                     discoveryError = new ServiceSearchError(ServiceSearchError.SEARCH_TERMINATED, errorMsg, rd);
00619                     break;
00620                     
00621                 default:
00622                     setState(NEW_SERVICE_SEARCH_ERROR);
00623                     errorMsg = "Response code sconosciuto";
00624                     discoveryError = new ServiceSearchError(ServiceSearchError.UNKNOWN_DISCOVERY_CODE, errorMsg, rd);
00625                     break;
00626             }
00627         }
00628         
00629         
00636         
00637         notifyObservers(discoveryError);
00638         
00639         /*
00640          ***************************************************************
00641          * controllo che la ricerca terminata sia l'ultima sottomessa
00642          ****************************************************************
00643          */
00644         
00645         /*
00646          * Se c'è ancora almeno una ricerca che deve terminare, reimposto lo
00647          * stato a SERVICE_SEARCH ed effettuo un return. Le operazioni
00648          * successive a questo if verranno effettuate solo
00649          * nel momento in cui termina l'ultima ricerca di servizi sottomessa
00650          */
00651         if (serviceSearches.size() > 0) {
00652             setState(this.SERVICE_SEARCH);
00653             notifyObservers();
00654             return;
00655         }
00656         
00657         /*
00658          * ok, tutte le ricerche di servizi richieste sono state completate
00659          * risveglio il thread sospeso che, dopo aver effettuato i controlli
00660          * sull'eventuale occorrenza di errori, imposterà
00661          * lo stato dell discoverer a READY
00662          */
00663         synchronized (this) {
00664             //risveglio il thread sospeso
00665             notify();
00666         }
00667     }

Questo è il grafo delle chiamate per questa funzione:

synchronized void org.jaebi.midlet.util.Observable.setChanged  )  [protected, inherited]
 

Marca questo oggetto Observable come changed.

Definizione alla linea 123 del file Observable.java.

Riferimenti org.jaebi.midlet.util.Observable.changed.

Referenziato da org.jaebi.midlet.bt.Discoverer.setState().

00123                                              {
00124         changed = true;
00125     }

void org.jaebi.midlet.bt.Discoverer.setState int  state  )  [private]
 

Definizione alla linea 177 del file Discoverer.java.

Riferimenti org.jaebi.midlet.util.Observable.setChanged().

Referenziato da org.jaebi.midlet.bt.Discoverer.run(), org.jaebi.midlet.bt.Discoverer.searchDevices(), org.jaebi.midlet.bt.Discoverer.searchServices(), e org.jaebi.midlet.bt.Discoverer.serviceSearchCompleted().

00177                                     {
00178         this.state = state;
00179         setChanged();
00180     }

Questo è il grafo delle chiamate per questa funzione:


Documentazione dei dati membri

int org.jaebi.midlet.bt.Discoverer.attrset[] [private]
 

insieme di attributi che un servizio deve avere per essere ritrovato da questo discoverer

Definizione alla linea 124 del file Discoverer.java.

Referenziato da org.jaebi.midlet.bt.Discoverer.Discoverer(), e org.jaebi.midlet.bt.Discoverer.searchServices().

boolean org.jaebi.midlet.bt.Discoverer.closed [private]
 

Definizione alla linea 114 del file Discoverer.java.

Referenziato da org.jaebi.midlet.bt.Discoverer.destroy(), org.jaebi.midlet.bt.Discoverer.Discoverer(), e org.jaebi.midlet.bt.Discoverer.scanDevicesServices().

final int org.jaebi.midlet.bt.DiscovererState.DEVICE_SEARCH = 1 [static, inherited]
 

Indica che il discoverer è in cerca di device bluettoth a cui collegarsi.

Definizione alla linea 22 del file DiscovererState.java.

Referenziato da org.jaebi.midlet.bt.Discoverer.cancelSearch(), e org.jaebi.midlet.bt.Discoverer.run().

final int org.jaebi.midlet.bt.DiscovererState.DISCOVERY_ERROR = 2 [static, inherited]
 

Indica che è avvenuto un errore che rende impossibile continuare le attività di ricerca.

Errori del genere sono quelli che avvengono durante l'inquiry o a causa di un'iterruzione del discovery

Definizione alla linea 27 del file DiscovererState.java.

Referenziato da org.jaebi.midlet.bt.Discoverer.searchDevices(), e org.jaebi.midlet.bt.Discoverer.searchServices().

DiscoveryAgent org.jaebi.midlet.bt.Discoverer.discoveryAgent [private]
 

Definizione alla linea 87 del file Discoverer.java.

Referenziato da org.jaebi.midlet.bt.Discoverer.cancelAllPendigServiceSearch(), org.jaebi.midlet.bt.Discoverer.cancelSearch(), org.jaebi.midlet.bt.Discoverer.cancelServiceSearch(), org.jaebi.midlet.bt.Discoverer.Discoverer(), org.jaebi.midlet.bt.Discoverer.searchDevices(), e org.jaebi.midlet.bt.Discoverer.searchServices().

DiscoveryReport org.jaebi.midlet.bt.Discoverer.discoveryReport [private]
 

tiene traccia delle device trovate durante l'inquiry e, per ogni device, dei servizi che offre

Definizione alla linea 95 del file Discoverer.java.

Referenziato da org.jaebi.midlet.bt.Discoverer.deviceDiscovered(), org.jaebi.midlet.bt.Discoverer.getDiscoveryReport(), org.jaebi.midlet.bt.Discoverer.run(), org.jaebi.midlet.bt.Discoverer.searchServices(), org.jaebi.midlet.bt.Discoverer.servicesDiscovered(), e org.jaebi.midlet.bt.Discoverer.serviceSearchCompleted().

int org.jaebi.midlet.bt.Discoverer.discType [private]
 

tiene traccia del codice ritornato dalla ricerca delle device

Definizione alla linea 112 del file Discoverer.java.

Referenziato da org.jaebi.midlet.bt.Discoverer.searchDevices().

LocalDevice org.jaebi.midlet.bt.Discoverer.localDevice [package]
 

Definizione alla linea 83 del file Discoverer.java.

Referenziato da org.jaebi.midlet.bt.Discoverer.Discoverer(), e org.jaebi.midlet.bt.Discoverer.searchServices().

final int org.jaebi.midlet.bt.DiscovererState.NEW_SERVICE_SEARCH_COMPLETE = 5 [static, inherited]
 

Indica che una delle ricerche di servizi sottomessa è stata completata.

NB questo stato indica che che solo UNA ricerca è completata ma non garantisce che ce ne possano essere altre in pending. Nel momento in cui non ci saranno più ricerche in pending il discoverer sarà READY

Definizione alla linea 41 del file DiscovererState.java.

Referenziato da org.jaebi.midlet.bt.Discoverer.serviceSearchCompleted().

final int org.jaebi.midlet.bt.DiscovererState.NEW_SERVICE_SEARCH_ERROR = 4 [static, inherited]
 

Indica che è avvenuto un errore durante la ricerca dei servizi disponibili.

Definizione alla linea 33 del file DiscovererState.java.

Referenziato da org.jaebi.midlet.bt.Discoverer.searchServices(), e org.jaebi.midlet.bt.Discoverer.serviceSearchCompleted().

final int org.jaebi.midlet.bt.DiscovererState.READY = 0 [static, inherited]
 

Indica che non ci sono nè ricerche di servizi nè ricerche di device in pending.

Definizione alla linea 19 del file DiscovererState.java.

Referenziato da org.jaebi.midlet.bt.Discoverer.run().

final int org.jaebi.midlet.bt.DiscovererState.SERVICE_SEARCH = 3 [static, inherited]
 

Indica che il discoverer è in cerca di servizi.

Definizione alla linea 30 del file DiscovererState.java.

Referenziato da org.jaebi.midlet.bt.Discoverer.cancelSearch(), org.jaebi.midlet.bt.Discoverer.run(), org.jaebi.midlet.bt.Discoverer.searchServices(), e org.jaebi.midlet.bt.Discoverer.serviceSearchCompleted().

Hashtable org.jaebi.midlet.bt.Discoverer.serviceSearches [private]
 

Ogni qual volta si inizia una ricerca dei servizi disponibili su una determinata device, il sistema associa un id a tale richiesta.

Questa var associa un id di ricerca servizi con la device su cui tale ricerca è stata sottomessa. siccome si effettua una sola ricerca di servizi per ogni device trovata durante l'inquiry, questa hashTable contiene tanti id quante sono le device trovate tramite searchDevice() (ossia esiste un'associazione 1:1 tra device torvate e id di ricerca) Ogni elemento di questa hashtable è quindi un riferimento ad una device bluetooth, memorizzato in chiave dell'id di ricerca servizi a cui la device è associata

Definizione alla linea 109 del file Discoverer.java.

Referenziato da org.jaebi.midlet.bt.Discoverer.cancelAllPendigServiceSearch(), org.jaebi.midlet.bt.Discoverer.cancelSearch(), org.jaebi.midlet.bt.Discoverer.searchServices(), e org.jaebi.midlet.bt.Discoverer.serviceSearchCompleted().

int org.jaebi.midlet.bt.Discoverer.state = READY [private]
 

tiene traccia dello stato corrente del discoverer.

Definizione alla linea 90 del file Discoverer.java.

Referenziato da org.jaebi.midlet.bt.Discoverer.cancelSearch().

UUID org.jaebi.midlet.bt.Discoverer.UUIDset[] [private]
 

insieme degli UUID che un servizio deve avere per essere ritrovato da questo discoverer

Definizione alla linea 119 del file Discoverer.java.

Referenziato da org.jaebi.midlet.bt.Discoverer.Discoverer(), e org.jaebi.midlet.bt.Discoverer.searchServices().


La documentazione per questa classe è stata generata a partire dal seguente file:
Generato il Thu Jun 23 00:03:02 2005 per JAEBI - BlueTooth J2ME Midlet Client da  doxygen 1.4.3