Changeset 41


Ignore:
Timestamp:
02/12/09 20:55:50 (13 years ago)
Author:
BegemoT
Message:

bluetooth

Location:
chess/src/chess
Files:
2 added
4 edited

Legend:

Unmodified
Added
Removed
  • chess/src/chess/remote/impl/BTNode.java

    r39 r41  
    99import javax.microedition.io.StreamConnection; 
    1010 
     11import chess.MSG; 
    1112import chess.remote.IConnectionListener; 
    1213import chess.remote.IDatagram; 
    1314import chess.remote.IRemoteNode; 
    14 import chess.MSG; 
    1515 
    1616 
     
    2323 */ 
    2424public class BTNode implements IRemoteNode, Runnable { 
    25     /** 
    26      * êàíàë BT, èñïîëüçóåìûé íàøèì ïðèëîæåíèåì 
    27      * todo ïîíÿòü, êàêèå êàíàëû ñóùåñòâóþò 
    28      */ 
    29     private static final String BT_STREAM = "1"; 
    30  
    31     private final String name; 
    32  
    33     private RemoteDevice device; 
    34     private final String connectionURL; 
    35     private IConnectionListener listener = null; 
    36     private StreamConnection connection = null; 
    37  
    38     private volatile boolean pumpShouldQuit = false; 
    39  
    40     private transient InputStream in; 
    41     private transient OutputStream out; 
    42     private transient Thread pump; 
    43  
    44     private Throwable lastError = null; 
    45  
    46     /** 
    47      * ìîíèòîð îæèäàíèÿ îòêðûòèÿ ñîåäèíåíèÿ 
    48      */ 
     25        /** 
     26         * êàíàë BT, èñïîëüçóåìûé íàøèì ïðèëîæåíèåì 
     27         * todo ïîíÿòü, êàêèå êàíàëû ñóùåñòâóþò 
     28         */ 
     29        private static final String BT_STREAM = "1"; 
     30 
     31        private final String name; 
     32 
     33        private RemoteDevice device; 
     34        private final String connectionURL; 
     35        private IConnectionListener listener = null; 
     36        private StreamConnection connection = null; 
     37 
     38        private volatile boolean pumpShouldQuit = false; 
     39 
     40        private transient InputStream in; 
     41        private transient OutputStream out; 
     42        private transient Thread pump; 
     43 
     44        private Throwable lastError = null; 
     45 
     46        /** ìîíèòîð îæèäàíèÿ îòêðûòèÿ ñîåäèíåíèÿ */ 
    4947//      private final Object connectLock = new Object(); 
    5048 
    51     private final Object queueOverloadedLock = new Object(); 
    52     private final IDatagram[] postQueue = new IDatagram[2]; 
    53  
    54  
    55     public BTNode( final RemoteDevice device ) throws IOException { 
    56         this( device, null ); 
    57     } 
    58  
    59     public BTNode( final StreamConnection conn ) throws IOException { 
    60         this( ( String )null, ( RemoteDevice )null, conn ); 
    61     } 
    62  
    63     public BTNode( final RemoteDevice device, 
    64                    final StreamConnection conn ) throws IOException { 
    65         this( null, device, conn ); 
    66     } 
    67  
    68     public BTNode( final String name, 
    69                    final StreamConnection conn ) throws IOException { 
    70         this( name, ( RemoteDevice )null, conn ); 
    71     } 
    72  
    73     public BTNode( final String name, 
    74                    final RemoteDevice device, 
    75                    final StreamConnection conn ) throws IOException { 
    76         if ( device == null && conn == null ) { 
    77             throw new IllegalArgumentException( "No-no-no, David Blain! device=null && conn=null" ); 
    78         } 
    79  
    80         if ( device == null ) { 
    81             this.device = RemoteDevice.getRemoteDevice( conn ); 
    82         } else { 
    83             this.device = device; 
    84         } 
    85         if ( name == null ) { 
    86             String _name = MSG.getMessage( "device.unknown" ); 
    87             try { 
    88                 _name = this.device.getFriendlyName( true ); 
    89             } catch ( IOException e ) { 
    90                 e.printStackTrace(); 
    91             } 
    92             this.name = _name; 
    93         } else { 
    94             this.name = name; 
    95         } 
    96  
    97         connectionURL = getBluetoothURL( device ); 
    98         connection = conn; 
    99     } 
    100  
    101     public BTNode( final String name, 
    102                    final ServiceRecord record ) throws IOException { 
    103         if ( record == null ) { 
    104             throw new IllegalArgumentException( "No-no-no, David Blain! record=null " ); 
    105         } 
    106  
    107         this.device = record.getHostDevice(); 
    108  
    109         if ( name == null ) { 
    110             String _name = MSG.getMessage( "device.unknown" ); 
    111             try { 
    112                 _name = this.device.getFriendlyName( true ); 
    113             } catch ( IOException e ) { 
    114                 e.printStackTrace(); 
    115             } 
    116             this.name = _name; 
    117         } else { 
    118             this.name = name; 
    119         } 
    120         connectionURL = record.getConnectionURL( 
    121                 ServiceRecord.NOAUTHENTICATE_NOENCRYPT, 
    122                 false 
    123         ); 
    124         connection = null; 
    125     } 
    126  
    127     public String getName() { 
    128         return name; 
    129     } 
    130  
    131     public synchronized void start() { 
    132         checkNotClosed(); 
    133         if ( !isStartCalled() ) { 
    134             pump = new Thread( this, "network pump" ); 
    135             pump.start(); 
    136         } 
    137     } 
    138  
    139     public synchronized void setListener( final IConnectionListener l ) { 
    140         if ( l != null && isClosed() ) { 
    141             throw new IllegalStateException( "Node is closed - listener is useless" ); 
    142         } 
    143         this.listener = l; 
    144     } 
    145  
    146     public void send( final IDatagram data ) { 
    147         checkPumpActive(); 
    148         while ( true ) { 
    149             //áëîêèðóåì this ÷òîáû íàñ íå çàêðûëè íåâîâðåìÿ 
    150             synchronized ( this ) { 
    151                 checkConnected(); 
    152                 try { 
    153                     synchronized ( postQueue ) { 
    154                         //áëîêèðóåì î÷åðåäü, ÷òîáû ïðåäóïðåäèòü åå èçìåíåíèÿ 
    155                         for ( int i = 0; i < postQueue.length; i++ ) { 
    156                             if ( postQueue[i] == null ) { 
    157                                 postQueue[i] = data; 
    158                                 return; 
    159                             } 
    160                         } 
    161                     } 
    162                 } finally { 
    163                     notifyAll();//push pump to run 
    164                 } 
    165             } 
    166             //åñëè î÷åðåäü ïåðåïîëíåíà -- âûíóæäåíû æäàòü 
    167             synchronized ( queueOverloadedLock ) { 
    168                 try { 
    169                     queueOverloadedLock.wait( 250 ); 
    170                 } catch ( InterruptedException e ) { 
    171                 } 
    172             } 
    173         } 
    174     } 
    175  
    176     public void run() { 
    177         try { 
    178             synchronized ( this ) { 
    179                 if ( isClosed() ) { 
    180                     return; 
    181                 } 
    182                 openPipeline(); 
    183             } 
    184             if ( listener != null ) { 
    185                 listener.connected(); 
    186             } 
    187             final GenericDatagram data = new GenericDatagram(); 
    188             while ( !isClosed() && !pumpShouldQuit ) { 
    189                 synchronized ( this ) { 
    190                     final int timeout; 
    191                     //îòïðàâëÿåì íåîòïðàâëåííîå 
    192                     synchronized ( postQueue ) { 
    193                         for ( int i = 0; i < postQueue.length; i++ ) { 
    194                             final IDatagram packet = postQueue[i]; 
    195                             if ( packet != null ) { 
    196                                 data.setWrapped( packet ); 
    197                                 data.write( out ); 
    198                                 postQueue[i] = null; 
    199                                 if ( listener != null ) { 
    200                                     listener.wasSent( packet ); 
    201                                 } 
    202                             } 
    203                         } 
    204                     } 
    205                     synchronized ( queueOverloadedLock ) { 
    206                         //îïîâåùàåì, ÷òî î÷åðåäü îñâîáîäèëàñü 
    207                         queueOverloadedLock.notifyAll(); 
    208                     } 
    209                     //÷èòàåì íåäî÷èòàííîå 
    210                     if ( in.available() > 0 ) { 
    211                         data.read( in ); 
    212                         if ( listener != null ) { 
    213                             listener.received( data.wrapped() ); 
    214                         } 
    215                         timeout = 50; 
    216                     } else { 
    217                         timeout = 250; 
    218                     } 
    219                     try { 
    220                         wait( timeout ); 
    221                     } catch ( InterruptedException e ) { 
    222                     } 
    223                 } 
    224             } 
    225         } catch ( Throwable e ) { 
    226             e.printStackTrace(); 
    227             lastError = e; 
    228         } finally { 
    229             pump = null; 
    230             closeImpl(); 
    231         } 
    232     } 
    233  
    234     private void openPipeline() throws IOException { 
    235         if ( connection == null ) { 
    236             connection = ( StreamConnection )Connector.open( 
    237                     connectionURL, 
    238                     Connector.READ_WRITE, 
    239                     true 
    240             ); 
    241         } 
    242         if ( in == null ) { 
    243             try { 
    244                 in = connection.openInputStream(); 
    245             } catch ( IOException ex ) { 
    246                 ex.printStackTrace(); 
    247                 throw ex; 
    248                 //throw new IOException( "Can't open input stream:" + ex.getMessage() ); 
    249             } 
    250         } 
    251         if ( out == null ) { 
    252             try { 
    253                 out = connection.openOutputStream(); 
    254             } catch ( IOException ex ) { 
    255                 ex.printStackTrace(); 
    256                 throw ex; 
    257                 //throw new IOException( "Can't open output stream:" + ex.getMessage() ); 
    258             } 
    259         } 
    260     } 
    261  
    262     public void close( final boolean safe ) { 
    263         if ( isClosed() ) { 
    264             return; 
    265         } 
    266         if ( safe ) { 
    267             askPumpToQuit(); 
    268         } else { 
    269             closeImpl(); 
    270         } 
    271     } 
    272  
    273     private void closeImpl() { 
    274         try { 
    275             if ( in != null ) { 
    276                 try { 
    277                     in.close(); 
    278                 } catch ( IOException e ) { 
    279                     e.printStackTrace(); 
    280                 } finally { 
    281                     in = null; 
    282                 } 
    283             } 
    284             if ( out != null ) { 
    285                 try { 
    286                     out.close(); 
    287                 } catch ( IOException e ) { 
    288                     e.printStackTrace(); 
    289                 } finally { 
    290                     out = null; 
    291                 } 
    292             } 
    293             if ( connection != null ) { 
    294                 try { 
    295                     connection.close(); 
    296                 } catch ( IOException e ) { 
    297                     e.printStackTrace(); 
    298                 } finally { 
    299                     connection = null; 
    300                 } 
    301             } 
    302  
    303             if ( pump != null && pump.isAlive() ) { 
    304                 pump.interrupt(); 
    305                 if ( pump != Thread.currentThread() ) { 
    306                     try { 
    307                         pump.join(); 
    308                     } catch ( InterruptedException e ) { 
    309                         e.printStackTrace(); 
    310                     } 
    311                 } 
    312             } 
    313             for ( int i = 0; i < postQueue.length; i++ ) { 
    314                 postQueue[i] = null; 
    315             } 
    316         } finally { 
    317             pump = null; 
    318             device = null; 
    319             if ( listener != null ) { 
    320                 listener.closed(); 
    321             } 
    322         } 
    323     } 
    324  
    325     private void askPumpToQuit() { 
    326         synchronized ( this ) { 
    327             pumpShouldQuit = true; 
    328             notifyAll(); 
    329         } 
    330         //device = null; 
    331     } 
    332  
    333     public Throwable getError() { 
    334         return lastError; 
    335     } 
    336  
    337     private void checkNotClosed() { 
    338         if ( isClosed() ) { 
    339             throw new IllegalStateException( "Node already closed" ); 
    340         } 
    341     } 
    342  
    343     private void checkPumpActive() { 
    344         checkNotClosed(); 
    345         if ( !isStartCalled() ) { 
    346             throw new IllegalStateException( ".start() not called" ); 
    347         } 
    348     } 
    349  
    350     private void checkConnected() { 
    351         checkNotClosed(); 
    352         checkPumpActive(); 
    353         if ( !isConnected() ) { 
    354             throw new IllegalStateException( "Node not connected" ); 
    355         } 
    356     } 
    357  
    358     private boolean isClosed() { 
    359         return device == null; 
    360     } 
    361  
    362     private boolean isStartCalled() { 
    363         return pump != null; 
    364     } 
    365  
    366     private boolean isConnected() { 
    367         return connection != null && in != null && out != null; 
    368     } 
    369  
    370     public String toString() { 
    371         return getName(); 
    372     } 
    373  
    374  
    375     public static String getBluetoothURL( final RemoteDevice device ) { 
    376         return BTRemote.SCHEME + device.getBluetoothAddress() + ":" + 
    377                 /*BTRemote.SERVICE_UUID.toString()*/ 
    378                 BT_STREAM; 
    379     } 
     49        private final Object queueOverloadedLock = new Object(); 
     50        private final IDatagram[] postQueue = new IDatagram[2]; 
     51 
     52 
     53        public BTNode( final RemoteDevice device ) throws IOException { 
     54                this( device, null ); 
     55        } 
     56 
     57        public BTNode( final StreamConnection conn ) throws IOException { 
     58                this( ( String ) null, ( RemoteDevice ) null, conn ); 
     59        } 
     60 
     61        public BTNode( final RemoteDevice device, 
     62                       final StreamConnection conn ) throws IOException { 
     63                this( null, device, conn ); 
     64        } 
     65 
     66        public BTNode( final String name, 
     67                       final StreamConnection conn ) throws IOException { 
     68                this( name, ( RemoteDevice ) null, conn ); 
     69        } 
     70 
     71        public BTNode( final String name, 
     72                       final RemoteDevice device, 
     73                       final StreamConnection conn ) throws IOException { 
     74                if( device == null && conn == null ) { 
     75                        throw new IllegalArgumentException( "No-no-no, David Blain! device=null && conn=null" ); 
     76                } 
     77 
     78                if( device == null ) { 
     79                        this.device = RemoteDevice.getRemoteDevice( conn ); 
     80                } else { 
     81                        this.device = device; 
     82                } 
     83                if( name == null ) { 
     84                        String _name = MSG.getMessage( "device.unknown" ); 
     85                        try { 
     86                                _name = this.device.getFriendlyName( true ); 
     87                        } catch( IOException e ) { 
     88                                e.printStackTrace(); 
     89                        } 
     90                        this.name = _name; 
     91                } else { 
     92                        this.name = name; 
     93                } 
     94 
     95                connectionURL = getBluetoothURL( this.device ); 
     96                connection = conn; 
     97        } 
     98 
     99        public BTNode( final ServiceRecord record ) throws IOException { 
     100                this( null, record ); 
     101        } 
     102 
     103        public BTNode( final String name, 
     104                       final ServiceRecord record ) throws IOException { 
     105                if( record == null ) { 
     106                        throw new IllegalArgumentException( "No-no-no, David Blain! record=null " ); 
     107                } 
     108 
     109                this.device = record.getHostDevice(); 
     110 
     111                if( name == null ) { 
     112                        String _name = MSG.getMessage( "device.unknown" ); 
     113                        try { 
     114                                _name = this.device.getFriendlyName( true ); 
     115                        } catch( IOException e ) { 
     116                                e.printStackTrace(); 
     117                        } 
     118                        this.name = _name; 
     119                } else { 
     120                        this.name = name; 
     121                } 
     122                connectionURL = record.getConnectionURL( 
     123                                ServiceRecord.NOAUTHENTICATE_NOENCRYPT, 
     124                                false 
     125                ); 
     126                connection = null; 
     127        } 
     128 
     129        public String getName() { 
     130                return name; 
     131        } 
     132 
     133        public synchronized void start() { 
     134                checkNotClosed(); 
     135                if( !isStartCalled() ) { 
     136                        pump = new Thread( this, "network pump" ); 
     137                        pump.start(); 
     138                } 
     139        } 
     140 
     141        public synchronized void setListener( final IConnectionListener l ) { 
     142                if( l != null && isClosed() ) { 
     143                        throw new IllegalStateException( "Node is closed - listener is useless" ); 
     144                } 
     145                this.listener = l; 
     146        } 
     147 
     148        public void send( final IDatagram data ) { 
     149                checkPumpActive(); 
     150                while( true ) { 
     151                        //áëîêèðóåì this ÷òîáû íàñ íå çàêðûëè íåâîâðåìÿ 
     152                        synchronized( this ) { 
     153                                checkConnected(); 
     154                                try { 
     155                                        synchronized( postQueue ) { 
     156                                                //áëîêèðóåì î÷åðåäü, ÷òîáû ïðåäóïðåäèòü åå èçìåíåíèÿ 
     157                                                for( int i = 0; i < postQueue.length; i++ ) { 
     158                                                        if( postQueue[i] == null ) { 
     159                                                                postQueue[i] = data; 
     160                                                                return; 
     161                                                        } 
     162                                                } 
     163                                        } 
     164                                } finally { 
     165                                        notifyAll();//push pump to run 
     166                                } 
     167                        } 
     168                        //åñëè î÷åðåäü ïåðåïîëíåíà -- âûíóæäåíû æäàòü 
     169                        synchronized( queueOverloadedLock ) { 
     170                                try { 
     171                                        queueOverloadedLock.wait( 250 ); 
     172                                } catch( InterruptedException e ) { 
     173                                } 
     174                        } 
     175                } 
     176        } 
     177 
     178        public void run() { 
     179                try { 
     180                        synchronized( this ) { 
     181                                if( isClosed() ) { 
     182                                        return; 
     183                                } 
     184                                openPipeline(); 
     185                        } 
     186                        if( listener != null ) { 
     187                                listener.connected(); 
     188                        } 
     189                        final GenericDatagram data = new GenericDatagram(); 
     190                        while( !isClosed() && !pumpShouldQuit ) { 
     191                                synchronized( this ) { 
     192                                        final int timeout; 
     193                                        //îòïðàâëÿåì íåîòïðàâëåííîå 
     194                                        synchronized( postQueue ) { 
     195                                                for( int i = 0; i < postQueue.length; i++ ) { 
     196                                                        final IDatagram packet = postQueue[i]; 
     197                                                        if( packet != null ) { 
     198                                                                data.setWrapped( packet ); 
     199                                                                data.write( out ); 
     200                                                                postQueue[i] = null; 
     201                                                                if( listener != null ) { 
     202                                                                        listener.wasSent( packet ); 
     203                                                                } 
     204                                                        } 
     205                                                } 
     206                                        } 
     207                                        synchronized( queueOverloadedLock ) { 
     208                                                //îïîâåùàåì, ÷òî î÷åðåäü îñâîáîäèëàñü 
     209                                                queueOverloadedLock.notifyAll(); 
     210                                        } 
     211                                        //÷èòàåì íåäî÷èòàííîå 
     212                                        if( in.available() > 0 ) { 
     213                                                data.read( in ); 
     214                                                if( listener != null ) { 
     215                                                        listener.received( data.wrapped() ); 
     216                                                } 
     217                                                timeout = 50; 
     218                                        } else { 
     219                                                timeout = 250; 
     220                                        } 
     221                                        try { 
     222                                                wait( timeout ); 
     223                                        } catch( InterruptedException e ) { 
     224                                        } 
     225                                } 
     226                        } 
     227                } catch( Throwable e ) { 
     228                        e.printStackTrace(); 
     229                        lastError = e; 
     230                } finally { 
     231                        pump = null; 
     232                        closeImpl(); 
     233                } 
     234        } 
     235 
     236        private void openPipeline() throws IOException { 
     237                if( connection == null ) { 
     238                        connection = ( StreamConnection ) Connector.open( 
     239                                        connectionURL, 
     240                                        Connector.READ_WRITE, 
     241                                        true 
     242                        ); 
     243                } 
     244                if( in == null ) { 
     245                        try { 
     246                                in = connection.openInputStream(); 
     247                        } catch( IOException ex ) { 
     248                                ex.printStackTrace(); 
     249                                throw ex; 
     250                                //throw new IOException( "Can't open input stream:" + ex.getMessage() ); 
     251                        } 
     252                } 
     253                if( out == null ) { 
     254                        try { 
     255                                out = connection.openOutputStream(); 
     256                        } catch( IOException ex ) { 
     257                                ex.printStackTrace(); 
     258                                throw ex; 
     259                                //throw new IOException( "Can't open output stream:" + ex.getMessage() ); 
     260                        } 
     261                } 
     262        } 
     263 
     264        public void close( final boolean safe ) { 
     265                if( isClosed() ) { 
     266                        return; 
     267                } 
     268                if( safe ) { 
     269                        askPumpToQuit(); 
     270                } else { 
     271                        closeImpl(); 
     272                } 
     273        } 
     274 
     275        private void closeImpl() { 
     276                try { 
     277                        if( in != null ) { 
     278                                try { 
     279                                        in.close(); 
     280                                } catch( IOException e ) { 
     281                                        e.printStackTrace(); 
     282                                } finally { 
     283                                        in = null; 
     284                                } 
     285                        } 
     286                        if( out != null ) { 
     287                                try { 
     288                                        out.close(); 
     289                                } catch( IOException e ) { 
     290                                        e.printStackTrace(); 
     291                                } finally { 
     292                                        out = null; 
     293                                } 
     294                        } 
     295                        if( connection != null ) { 
     296                                try { 
     297                                        connection.close(); 
     298                                } catch( IOException e ) { 
     299                                        e.printStackTrace(); 
     300                                } finally { 
     301                                        connection = null; 
     302                                } 
     303                        } 
     304 
     305                        if( pump != null && pump.isAlive() ) { 
     306                                pump.interrupt(); 
     307                                if( pump != Thread.currentThread() ) { 
     308                                        try { 
     309                                                pump.join(); 
     310                                        } catch( InterruptedException e ) { 
     311                                                e.printStackTrace(); 
     312                                        } 
     313                                } 
     314                        } 
     315                        for( int i = 0; i < postQueue.length; i++ ) { 
     316                                postQueue[i] = null; 
     317                        } 
     318                } finally { 
     319                        pump = null; 
     320                        device = null; 
     321                        if( listener != null ) { 
     322                                listener.closed(); 
     323                        } 
     324                } 
     325        } 
     326 
     327        private void askPumpToQuit() { 
     328                synchronized( this ) { 
     329                        pumpShouldQuit = true; 
     330                        notifyAll(); 
     331                } 
     332                //device = null; 
     333        } 
     334 
     335        public Throwable getError() { 
     336                return lastError; 
     337        } 
     338 
     339        private void checkNotClosed() { 
     340                if( isClosed() ) { 
     341                        throw new IllegalStateException( "Node already closed" ); 
     342                } 
     343        } 
     344 
     345        private void checkPumpActive() { 
     346                checkNotClosed(); 
     347                if( !isStartCalled() ) { 
     348                        throw new IllegalStateException( ".start() not called" ); 
     349                } 
     350        } 
     351 
     352        private void checkConnected() { 
     353                checkNotClosed(); 
     354                checkPumpActive(); 
     355                if( !isConnected() ) { 
     356                        throw new IllegalStateException( "Node not connected" ); 
     357                } 
     358        } 
     359 
     360        private boolean isClosed() { 
     361                return device == null; 
     362        } 
     363 
     364        private boolean isStartCalled() { 
     365                return pump != null; 
     366        } 
     367 
     368        private boolean isConnected() { 
     369                return connection != null && in != null && out != null; 
     370        } 
     371 
     372        public String toString() { 
     373                return getName(); 
     374        } 
     375 
     376 
     377        public static String getBluetoothURL( final RemoteDevice device ) { 
     378                return BTRemote.SCHEME + device.getBluetoothAddress() + ":" + 
     379                                /*BTRemote.SERVICE_UUID.toString()*/ 
     380                                BT_STREAM; 
     381        } 
    380382} 
  • chess/src/chess/remote/impl/BTRemote.java

    r39 r41  
    22 
    33import java.io.IOException; 
    4 import java.io.InterruptedIOException; 
    54import java.util.*; 
    65import javax.bluetooth.*; 
    7 import javax.microedition.io.Connector; 
    8 import javax.microedition.io.StreamConnection; 
    9 import javax.microedition.io.StreamConnectionNotifier; 
     6import javax.bluetooth.UUID; 
    107 
    11 import chess.Util; 
    128import chess.remote.*; 
    139 
     
    2824 
    2925    private final LocalDevice localDevice; 
    30     private final Vector devices = new Vector(); 
     26 
     27        private final Vector/*<RemoteDevice>*/ devices = new Vector(); 
     28//      private final Vector/*<ServiceRecord>*/ services = new Vector(); 
    3129 
    3230    public BTRemote() throws Exception { 
     
    5351    } 
    5452 
    55     private synchronized void refreshCache() { 
     53    synchronized void refreshCache() { 
    5654        devices.removeAllElements(); 
    5755        fillupCache(); 
     
    6866    } 
    6967 
    70     private synchronized IRemoteNode[] getNodes() { 
     68        synchronized Vector/*RemoteDevice*/ getCachedDevices(){ 
     69                return devices; 
     70        } 
     71 
     72    synchronized IRemoteNode[] getNodes() { 
    7173        if ( devices.isEmpty() ) { 
    7274            return EMPTY; 
     
    103105    } 
    104106 
    105     private static class WaitForIncomingThread extends BaseAsyncProcess { 
    106         private final LocalDevice localDevice; 
    107         private StreamConnectionNotifier server; 
    108  
    109         public WaitForIncomingThread( final LocalDevice local, 
    110                                       final IServerListener listener ) { 
    111             super( listener, "wait-for-incoming" ); 
    112             this.localDevice = local; 
    113             start(); 
    114         } 
    115  
    116         protected void runImpl() { 
    117             try { 
    118                 localDevice.setDiscoverable( DiscoveryAgent.GIAC ); 
    119                 while ( !isInterruptQueried() ) { 
    120                     server = ( StreamConnectionNotifier )Connector.open( 
    121                             SCHEME + "localhost:" + SERVICE_SUUID + ";name=" + SERVICE_NAME, 
    122                             Connector.READ_WRITE, 
    123                             true 
    124                     ); 
    125                     //final ServiceRecord sr = localDevice.getRecord( server );                     
    126                     Util.log.println( "creating server and waiting for incoming" ); 
    127                     try { 
    128                         final IServerListener _listener = ( IServerListener )listener; 
    129                         while ( !isInterruptQueried() && server != null ) { 
    130                             // Îæèäàåì âõîäÿùåå ïîòîêîâîå ñîåäèíåíèå 
    131                             final StreamConnection conn = server.acceptAndOpen(); 
    132                             Util.log.println( "accepted incoming: " + conn ); 
    133                             final BTNode client = new BTNode( conn ); 
    134                             if ( _listener.incoming( client ) ) { 
    135                                 //åñëè êëèåíò ïðèíÿò -- âûõîäèì (èãðà äîïóñêàåò òîëüêî îäíîãî ñîïåðíèêà) 
    136                                 Util.log.println( "client accepted -> close server" ); 
    137                                 setStatus( SUCCEEDED ); 
    138                                 return; 
    139                             } else { 
    140                                 client.close( true ); 
    141                             } 
    142                         } 
    143                     } catch ( InterruptedIOException ex ) { 
    144                         throw ex; 
    145                     } catch ( IOException ex ) { 
    146                         Util.log.println( "server got error -- trying to recreate server connection" ); 
    147                         ex.printStackTrace(); 
    148                     } finally { 
    149                         if ( server != null ) { 
    150                             try { 
    151                                 server.close(); 
    152                                 server = null; 
    153                             } catch ( IOException e ) { 
    154                                 e.printStackTrace(); 
    155                             } 
    156                         } 
    157                     } 
    158                 } 
    159             } catch ( Throwable ex ) { 
    160                 //åñëè íå óäàëîñü îòêðûòü ñîåäèíåíèå -- ýòî ïèçäåö. óõîäèì 
    161                 //...íå óäàëîñü îïóáëèêîâàòü óñòðîéñòâî -- ïèçäåö, óõîäèì 
    162                 if ( isInterruptQueried() ) { 
    163                     Util.log.println( "server was closed: " + ex.getMessage() ); 
    164                     setStatus( INTERRUPTED ); 
    165                 } else { 
    166                     setStatus( FAILED, ex ); 
    167                 } 
    168             } finally { 
    169                 postFinishedEvent( null ); 
    170                 try { 
    171                     localDevice.setDiscoverable( DiscoveryAgent.NOT_DISCOVERABLE ); 
    172                 } catch ( BluetoothStateException e ) { 
    173                     e.printStackTrace(); 
    174                 } 
    175                 Util.log.println( "server stopped" ); 
    176             } 
    177         } 
    178  
    179         public void stop( final int waitMillis ) { 
    180             queryForInterrupt(); 
    181             if ( isAlive() ) { 
    182                 if ( server != null ) { 
    183                     try { 
    184                         server.close(); 
    185                         server = null; 
    186                     } catch ( IOException e ) { 
    187                         e.printStackTrace(); 
    188                     } 
    189                 } 
    190                 waitForThread( waitMillis ); 
    191             } 
    192         } 
    193     } 
    194  
    195     private static class QueryDeviceProcess extends BaseAsyncProcess implements DiscoveryListener { 
    196         private final BTRemote remote; 
    197         private final boolean realQuery; 
    198         private final DiscoveryAgent agent; 
    199  
    200         public QueryDeviceProcess( final BTRemote remote, 
    201                                    final boolean realQuery, 
    202                                    final DiscoveryAgent agent, 
    203                                    final IClientListener listener ) { 
    204             super( listener, "query-device-list" ); 
    205             this.remote = remote; 
    206             this.agent = agent; 
    207             this.realQuery = realQuery; 
    208             start(); 
    209         } 
    210  
    211         protected void runImpl() { 
    212             Util.log.println( "starting query device list" ); 
    213             try { 
    214                 /** 
    215                  * Íåïîíÿòíî, ÿâëÿåòñÿ ëè ýòîò çàïðîñ ñèíõðîííûì, èëè àñèíõðîííûì -- 
    216                  * äîêóìåíòàöèÿ íà ýòîò ñ÷åò ìîë÷èò, à ïðàêòèêà ïîêàçûâàåò, ÷òî 
    217                  * áûâàåò è òàê è ýäàê. Ïîýòîìó ñòðàõóåìñÿ îò íåâåäîìîé õóéíè è 
    218                  * äåëàåì ýòî â îòäåëüíîì ïîòîêå 
    219                  */ 
    220                 if ( realQuery ) { 
    221                     final boolean res = agent.startInquiry( DiscoveryAgent.GIAC, this ); 
    222                     if ( !res ) { 
    223                         if ( isInterruptQueried() ) { 
    224                             setStatus( INTERRUPTED ); 
    225                         } else { 
    226                             setStatus( FAILED ); 
    227                         } 
    228                         postFinishedEvent( null ); 
    229                     } 
    230                 } else { 
    231                     final IRemoteNode[] nodes = remote.getNodes(); 
    232                     setStatus( SUCCEEDED ); 
    233                     postFinishedEvent( nodes ); 
    234                 } 
    235             } catch ( Throwable e ) { 
    236                 if ( isInterruptQueried() ) { 
    237                     setStatus( INTERRUPTED ); 
    238                 } else { 
    239                     setStatus( FAILED, e ); 
    240                 } 
    241                 postFinishedEvent( null ); 
    242             } 
    243         } 
    244  
    245         public void stop( final int waitMillis ) { 
    246             queryForInterrupt(); 
    247             if ( status() == IN_PROCESS ) { 
    248                 if ( realQuery ) { 
    249                     final boolean res = agent.cancelInquiry( this ); 
    250                     if ( !res ) { 
    251                         interrupt(); 
    252                     } 
    253                 } else { 
    254                     interrupt(); 
    255                 } 
    256                 waitForThread( waitMillis ); 
    257             } 
    258             /** Äåëàåì ýòî íà âñÿêèé ñëó÷àé -- èíîãäà ïî÷åìó-òî 
    259              * ïðè îòìåíå çàïðîñà inquiryCompleted íå âûçûâàåòñÿ 
    260              */ 
    261             if ( status() == IN_PROCESS ) { 
    262                 setStatus( INTERRUPTED ); 
    263             } 
    264             postFinishedEvent( null ); 
    265         } 
    266  
    267         private static final int SERVICE_NAME_ATTR_ID = 0x0100; 
    268         private static final int[] attrSet = new int[]{ SERVICE_NAME_ATTR_ID }; 
    269         private static final UUID[] uuids = new UUID[]{ SERVICE_UUID }; 
    270  
    271         public void deviceDiscovered( final RemoteDevice btDevice, 
    272                                       final DeviceClass cod ) { 
    273             Util.log.println( "device found:" + btDevice.getBluetoothAddress() ); 
    274             //todo ôèëüòðîâàòü DeviceClass, ÷òîáû íå ïîäêëþ÷àòüñÿ èãðàòü ê íàóøíèêàì :)  
    275             try { 
    276                 final int transID = agent.searchServices( attrSet, uuids, btDevice, this ); 
    277             } catch ( BluetoothStateException e ) { 
    278                 e.printStackTrace(); 
    279             } 
    280         } 
    281  
    282         public void servicesDiscovered( final int transID, 
    283                                         final ServiceRecord[] servRecord ) { 
    284             Util.log.println( "services found, transID=" + transID ); 
    285             for ( int i = 0; i < servRecord.length; i++ ) { 
    286                 final ServiceRecord record = servRecord[i]; 
    287                 final String cUrl = record.getConnectionURL( ServiceRecord.NOAUTHENTICATE_NOENCRYPT, false ); 
    288                 final DataElement value = record.getAttributeValue( SERVICE_NAME_ATTR_ID ); 
    289                 Util.log.println( "\tservice:" + cUrl + ", name=" + value.getValue() ); 
    290             } 
    291         } 
    292  
    293         public void serviceSearchCompleted( final int transID, 
    294                                             final int respCode ) { 
    295             Util.log.println( "service search completed:" + transID ); 
    296         } 
    297  
    298         public void inquiryCompleted( final int discType ) { 
    299             remote.refreshCache(); 
    300             switch ( discType ) { 
    301                 case INQUIRY_COMPLETED: 
    302                     Util.log.println( "device list query finished" ); 
    303                     setStatus( SUCCEEDED ); 
    304                     postFinishedEvent( remote.getNodes() ); 
    305                     break; 
    306                 case INQUIRY_TERMINATED: 
    307                     Util.log.println( "device list query interrupted" ); 
    308                     setStatus( INTERRUPTED ); 
    309                     postFinishedEvent( null ); 
    310                     break; 
    311                 case INQUIRY_ERROR: 
    312                     Util.log.println( "device list query failed" ); 
    313                     setStatus( FAILED ); 
    314                     postFinishedEvent( null ); 
    315                     break; 
    316                 default: 
    317                     setStatus( FAILED ); 
    318                     postFinishedEvent( null ); 
    319                     throw new IllegalStateException( "Unknown type:" + discType ); 
    320             } 
    321         } 
    322     } 
    323107} 
  • chess/src/chess/remote/impl/BaseAsyncProcess.java

    r39 r41  
    44import chess.remote.IAsyncProcess; 
    55import chess.remote.IAsyncProcessListener; 
    6 import chess.remote.IRemoteNode; 
    76 
    87/** 
     
    130129            listener.finished( res ); 
    131130            finishedEventWasPost = true; 
     131//              listener = null; 
    132132        } else { 
    133133            Util.log.println( "WARN:dublicate 'finished' event post!" ); 
  • chess/src/chess/ui/ChessMIDlet.java

    r36 r41  
    2020 */ 
    2121public class ChessMIDlet extends MIDlet implements CommandListener, ItemCommandListener { 
    22     static { 
    23         MSG.initLocalizationSupport(); 
    24     } 
    25  
    26     /* commands */ 
    27     public final Command yesCommand = new Command( MSG.getMessage( "command.yes" ), Command.OK, 1 ); 
    28     public final Command noCommand = new Command( MSG.getMessage( "command.no" ), Command.CANCEL, 1 ); 
    29  
    30     public final Command okCommand = new Command( MSG.getMessage( "command.ok" ), Command.OK, 1 ); 
    31     public final Command cancelCommand = new Command( MSG.getMessage( "command.cancel" ), Command.CANCEL, 1 ); 
    32  
    33     public final Command backCommand = new Command( MSG.getMessage( "command.back" ), Command.BACK, 1 ); 
    34  
    35     public final Command refreshCommand = new Command( MSG.getMessage( "command.refresh" ), Command.SCREEN, 1 ); 
    36  
    37     public final Command newCommand = new Command( MSG.getMessage( "command.new" ), Command.SCREEN, 1 ); 
    38  
    39     public final Command joinCommand = new Command( MSG.getMessage( "command.join" ), Command.SCREEN, 1 ); 
    40  
    41     public final Command helpCommand = new Command( MSG.getMessage( "command.help" ), Command.HELP, 1 ); 
    42  
    43     public final Command exitCommand = new Command( MSG.getMessage( "command.exit" ), Command.EXIT, 1 ); 
    44  
    45     /* GUI */ 
    46     public final Display display; 
    47  
    48     public final Screen startForm = new StartMenuScreen( this ); 
    49     private final Screen choosePlayerForm = new ChoosePlayerScreen( this ); 
    50     private final GameCanvas gameCanvas = new GameCanvas( this ); 
    51     private final WaitCanvas waitScreen = new WaitCanvas( 
    52             this, 
    53             MSG.getMessage( "wait-for-bluetooth.title" ), 
    54             gameCanvas 
    55     ); 
    56     private final JoinGameScreen searchForm = new JoinGameScreen( this ); 
    57     private final Screen helpScreen = new HelpScreen( this ); 
    58  
    59     /* network */ 
    60     private final IRemote remote; 
    61  
    62     /* current game application */ 
    63     private App app; 
    64     private IAsyncProcess waitForIncomingProcess; 
    65  
    66     public ChessMIDlet() throws Exception { 
    67         display = Display.getDisplay( this ); 
    68         remote = Util.create(); 
    69  
    70         waitScreen.addCommand( cancelCommand ); 
    71         waitScreen.setCommandListener( this ); 
    72     } 
    73  
    74     public IRemote getRemoteManager() { 
    75         return remote; 
    76     } 
    77  
    78     public void connectToServer( final IRemoteNode server ) { 
    79         try { 
    80             display.setCurrent( gameCanvas ); 
    81             app = new App( 
    82                     ChessMIDlet.this, 
    83                     new Game(), 
    84                     gameCanvas, 
    85                     server 
    86             ); 
    87         } catch ( Exception e ) { 
    88             e.printStackTrace(); 
    89         } 
    90         //display.setCurrent( gameCanvas ); 
    91     } 
    92  
    93     protected void startApp() { 
    94         if ( display.getCurrent() == null ) { 
    95             showStartScreen(); 
    96         } 
    97     } 
    98  
    99     protected void pauseApp() { 
    100         //todo pause threads? 
    101     } 
    102  
    103     protected void destroyApp( boolean unconditional ) { 
    104         //todo remote.close() 
    105         ensureServerClosed(); 
    106         app = null; 
    107         notifyDestroyed(); 
    108     } 
    109  
    110     private void ensureServerClosed() { 
    111         if ( waitForIncomingProcess != null ) { 
    112             waitForIncomingProcess.stop( 1000 ); 
    113             waitForIncomingProcess = null; 
    114         } 
    115     } 
    116  
    117     public void showStartScreen() { 
    118         display.setCurrent( startForm ); 
    119         Util.log.println( "start menu" ); 
    120     } 
    121  
    122     protected void choosePlayer() { 
    123         display.setCurrent( choosePlayerForm ); 
    124         Util.log.println( "choose player" ); 
    125     } 
    126  
    127     protected void newGame( final Player player ) { 
    128         ensureServerClosed(); 
    129         display.setCurrent( waitScreen ); 
    130         Util.log.println( "new game:" + player ); 
    131         waitForIncomingProcess = remote.waitForIncoming( 
    132                 new IServerListener() { 
    133                     private boolean retValue = false; 
    134                     private IRemoteNode client; 
    135  
    136                     public synchronized boolean incoming( final IRemoteNode client ) { 
    137                         final Alert dlg = new Alert( 
    138                                 MSG.getMessage( "new-game.incoming-client" ), 
    139                                 MSG.getMessage( 
    140                                         "new-game.incoming-client.description", 
    141                                         new Object[]{ client.getName() } 
    142                                 ), 
    143                                 null, 
    144                                 AlertType.CONFIRMATION 
    145                         ); 
    146                         //dlg.setTimeout( Alert.FOREVER ) is implicitly set if 
    147                         //Alert has 2 or more commands -- see javadoc 
    148                         dlg.addCommand( yesCommand ); 
    149                         dlg.addCommand( noCommand ); 
    150                         dlg.setCommandListener( 
    151                                 new CommandListener() { 
    152                                     public void commandAction( final Command command, 
    153                                                                final Displayable displayable ) { 
    154                                         try { 
    155                                             //Util.log.println( command ); 
    156                                             if ( command == yesCommand ) { 
    157                                                 retValue = true; 
    158                                             } else { 
    159                                                 retValue = false; 
    160                                             } 
    161                                         } finally { 
    162                                             synchronized ( ChessMIDlet.this ) { 
    163                                                 ChessMIDlet.this.notifyAll(); 
    164                                             } 
    165                                             display.setCurrent( waitScreen ); 
    166                                         } 
    167                                     } 
    168                                 } 
    169                         ); 
    170                         display.setCurrent( dlg ); 
    171                         synchronized ( ChessMIDlet.this ) { 
    172                             try { 
    173                                 ChessMIDlet.this.wait(); 
    174                             } catch ( InterruptedException e ) { 
    175                                 //e.printStackTrace(); 
    176                             } 
    177                         } 
    178                         if ( retValue ) { 
    179                             this.client = client; 
    180                         } 
    181                         return retValue; 
    182                     } 
    183  
    184                     public void finished( final Object res ) { 
    185                         //todo display error message if failed 
    186                         final int status = waitForIncomingProcess.status(); 
    187                         switch ( status ) { 
    188                             case IAsyncProcess.SUCCEEDED: 
    189                                 waitScreen.finished( res ); 
    190                                 try { 
    191                                     app = new App( 
    192                                             ChessMIDlet.this, 
    193                                             new Game(), 
    194                                             gameCanvas, 
    195                                             client, 
    196                                             player 
    197                                     ); 
    198                                     Util.log.println( "joined client" ); 
    199                                 } catch ( Exception e ) { 
    200                                     e.printStackTrace(); 
    201                                 } 
    202                                 break; 
    203                             case IAsyncProcess.FAILED: 
    204                                 final Alert alert = Util.createErrorDialog(  
    205                                         "Error in starting server" 
    206                                 ); 
    207                                 display.setCurrent( alert, startForm ); 
    208                                 break; 
    209                             case IAsyncProcess.INTERRUPTED: 
    210                                 display.setCurrent( startForm ); 
    211                                 break; 
    212                         } 
    213                         waitForIncomingProcess = null; 
    214                     } 
    215                 } 
    216         ); 
    217     } 
    218  
    219     public void searchGame() { 
    220         display.setCurrent( searchForm ); 
    221         searchForm.refresh( false ); 
    222         Util.log.println( "search server" ); 
    223     } 
    224  
    225     public void showHelp() { 
    226         display.setCurrent( helpScreen ); 
    227         Util.log.println( "show help" ); 
    228     } 
    229  
    230     public void exitGame() { 
    231         destroyApp( true ); 
    232         notifyDestroyed(); 
    233     } 
    234  
    235     public void commandAction( final Command c, 
    236                                final Displayable d ) { 
    237         if ( d == waitScreen ) { 
    238             if ( c == cancelCommand ) { 
    239                 ensureServerClosed(); 
    240             } 
    241         } 
    242         if ( c == exitCommand ) { 
    243             exitGame(); 
    244         } else if ( c == newCommand ) { 
    245             choosePlayer(); 
    246         } else if ( c == joinCommand ) { 
    247             searchGame(); 
    248         } else if ( c == helpCommand ) { 
    249             showHelp(); 
    250         } 
    251     } 
    252  
    253     public void commandAction( final Command command, 
    254                                final Item item ) { 
    255  
    256     } 
     22        static { 
     23                MSG.initLocalizationSupport(); 
     24        } 
     25 
     26        /* commands */ 
     27        public final Command yesCommand = new Command( MSG.getMessage( "command.yes" ), Command.OK, 1 ); 
     28        public final Command noCommand = new Command( MSG.getMessage( "command.no" ), Command.CANCEL, 1 ); 
     29 
     30        public final Command okCommand = new Command( MSG.getMessage( "command.ok" ), Command.OK, 1 ); 
     31        public final Command cancelCommand = new Command( MSG.getMessage( "command.cancel" ), Command.CANCEL, 1 ); 
     32 
     33        public final Command backCommand = new Command( MSG.getMessage( "command.back" ), Command.BACK, 1 ); 
     34 
     35        public final Command refreshCommand = new Command( MSG.getMessage( "command.refresh" ), Command.SCREEN, 1 ); 
     36 
     37        public final Command newCommand = new Command( MSG.getMessage( "command.new" ), Command.SCREEN, 1 ); 
     38 
     39        public final Command joinCommand = new Command( MSG.getMessage( "command.join" ), Command.SCREEN, 1 ); 
     40 
     41        public final Command helpCommand = new Command( MSG.getMessage( "command.help" ), Command.HELP, 1 ); 
     42 
     43        public final Command exitCommand = new Command( MSG.getMessage( "command.exit" ), Command.EXIT, 1 ); 
     44 
     45        /* GUI */ 
     46        public final Display display; 
     47 
     48        public final Screen startForm = new StartMenuScreen( this ); 
     49        private final Screen choosePlayerForm = new ChoosePlayerScreen( this ); 
     50        private final GameCanvas gameCanvas = new GameCanvas( this ); 
     51        private final WaitCanvas waitScreen = new WaitCanvas( 
     52                        this, 
     53                        MSG.getMessage( "wait-for-bluetooth.title" ), 
     54                        gameCanvas 
     55        ); 
     56        private final JoinGameScreen searchForm = new JoinGameScreen( this ); 
     57        private final Screen helpScreen = new HelpScreen( this ); 
     58 
     59        /* network */ 
     60        private final IRemote remote; 
     61 
     62        /* current game application */ 
     63        private App app; 
     64        private IAsyncProcess waitForIncomingProcess; 
     65 
     66        public ChessMIDlet() throws Exception { 
     67                display = Display.getDisplay( this ); 
     68                remote = Util.create(); 
     69 
     70                waitScreen.addCommand( cancelCommand ); 
     71                waitScreen.setCommandListener( this ); 
     72        } 
     73 
     74        public IRemote getRemoteManager() { 
     75                return remote; 
     76        } 
     77 
     78        public void connectToServer( final IRemoteNode server ) { 
     79                try { 
     80                        display.setCurrent( gameCanvas ); 
     81                        app = new App( 
     82                                        ChessMIDlet.this, 
     83                                        new Game(), 
     84                                        gameCanvas, 
     85                                        server 
     86                        ); 
     87                } catch( Exception e ) { 
     88                        e.printStackTrace(); 
     89                } 
     90                //display.setCurrent( gameCanvas ); 
     91        } 
     92 
     93        protected void startApp() { 
     94                if( display.getCurrent() == null ) { 
     95                        showStartScreen(); 
     96                } 
     97        } 
     98 
     99        protected void pauseApp() { 
     100                //todo pause threads? 
     101        } 
     102 
     103        protected void destroyApp( boolean unconditional ) { 
     104                //todo remote.close() 
     105                ensureServerClosed(); 
     106                app = null; 
     107                notifyDestroyed(); 
     108        } 
     109 
     110        private void ensureServerClosed() { 
     111                if( waitForIncomingProcess != null ) { 
     112                        waitForIncomingProcess.stop( 1000 ); 
     113//            waitForIncomingProcess = null; 
     114                } 
     115        } 
     116 
     117        public void showStartScreen() { 
     118                display.setCurrent( startForm ); 
     119                Util.log.println( "start menu" ); 
     120        } 
     121 
     122        protected void choosePlayer() { 
     123                display.setCurrent( choosePlayerForm ); 
     124                Util.log.println( "choose player" ); 
     125        } 
     126 
     127        protected void newGame( final Player player ) { 
     128                ensureServerClosed(); 
     129                display.setCurrent( waitScreen ); 
     130                Util.log.println( "new game:" + player ); 
     131                waitForIncomingProcess = remote.waitForIncoming( 
     132                                new IServerListener() { 
     133                                        private boolean retValue = false; 
     134                                        private IRemoteNode client; 
     135 
     136                                        public synchronized boolean incoming( final IRemoteNode client ) { 
     137                                                waitScreen.setText( "client incoming" ); 
     138                                                final Alert dlg = new Alert( 
     139                                                                MSG.getMessage( "new-game.incoming-client" ), 
     140                                                                MSG.getMessage( 
     141                                                                                "new-game.incoming-client.description", 
     142                                                                                new Object[] { client.getName() } 
     143                                                                ), 
     144                                                                null, 
     145                                                                AlertType.CONFIRMATION 
     146                                                ); 
     147                                                //dlg.setTimeout( Alert.FOREVER ) is implicitly set if 
     148                                                //Alert has 2 or more commands -- see javadoc 
     149                                                dlg.addCommand( yesCommand ); 
     150                                                dlg.addCommand( noCommand ); 
     151                                                dlg.setCommandListener( 
     152                                                                new CommandListener() { 
     153                                                                        public void commandAction( final Command command, 
     154                                                                                                   final Displayable displayable ) { 
     155                                                                                try { 
     156                                                                                        //Util.log.println( command ); 
     157                                                                                        if( command == yesCommand ) { 
     158                                                                                                retValue = true; 
     159                                                                                        } else { 
     160                                                                                                retValue = false; 
     161                                                                                        } 
     162                                                                                } finally { 
     163                                                                                        synchronized( ChessMIDlet.this ) { 
     164                                                                                                ChessMIDlet.this.notifyAll(); 
     165                                                                                        } 
     166                                                                                        display.setCurrent( waitScreen ); 
     167                                                                                } 
     168                                                                        } 
     169                                                                } 
     170                                                ); 
     171                                                display.setCurrent( dlg ); 
     172                                                synchronized( ChessMIDlet.this ) { 
     173                                                        try { 
     174                                                                ChessMIDlet.this.wait(); 
     175                                                        } catch( InterruptedException e ) { 
     176                                                                //e.printStackTrace(); 
     177                                                        } 
     178                                                } 
     179                                                if( retValue ) { 
     180                                                        this.client = client; 
     181                                                } 
     182                                                return retValue; 
     183                                        } 
     184 
     185                                        public void finished( final Object res ) { 
     186                                                //todo display error message if failed 
     187                                                final int status = waitForIncomingProcess.status(); 
     188                                                switch( status ) { 
     189                                                        case IAsyncProcess.SUCCEEDED: 
     190                                                                waitScreen.finished( res ); 
     191                                                                try { 
     192                                                                        app = new App( 
     193                                                                                        ChessMIDlet.this, 
     194                                                                                        new Game(), 
     195                                                                                        gameCanvas, 
     196                                                                                        client, 
     197                                                                                        player 
     198                                                                        ); 
     199                                                                        Util.log.println( "joined client" ); 
     200                                                                } catch( Exception e ) { 
     201                                                                        e.printStackTrace(); 
     202                                                                } 
     203                                                                break; 
     204                                                        case IAsyncProcess.FAILED: 
     205                                                                final Alert alert = Util.createErrorDialog( 
     206                                                                                "Error in starting server" 
     207                                                                ); 
     208                                                                display.setCurrent( alert, startForm ); 
     209                                                                break; 
     210                                                        case IAsyncProcess.INTERRUPTED: 
     211                                                                display.setCurrent( startForm ); 
     212                                                                break; 
     213                                                } 
     214                                                waitForIncomingProcess = null; 
     215                                        } 
     216                                } 
     217                ); 
     218        } 
     219 
     220        public void searchGame() { 
     221                display.setCurrent( searchForm ); 
     222                searchForm.refresh( false ); 
     223                Util.log.println( "search server" ); 
     224        } 
     225 
     226        public void showHelp() { 
     227                display.setCurrent( helpScreen ); 
     228                Util.log.println( "show help" ); 
     229        } 
     230 
     231        public void exitGame() { 
     232                destroyApp( true ); 
     233                notifyDestroyed(); 
     234        } 
     235 
     236        public void commandAction( final Command c, 
     237                                   final Displayable d ) { 
     238                if( d == waitScreen ) { 
     239                        if( c == cancelCommand ) { 
     240                                ensureServerClosed(); 
     241                        } 
     242                } 
     243                if( c == exitCommand ) { 
     244                        exitGame(); 
     245                } else if( c == newCommand ) { 
     246                        choosePlayer(); 
     247                } else if( c == joinCommand ) { 
     248                        searchGame(); 
     249                } else if( c == helpCommand ) { 
     250                        showHelp(); 
     251                } 
     252        } 
     253 
     254        public void commandAction( final Command command, 
     255                                   final Item item ) { 
     256 
     257        } 
    257258 
    258259//      public static void main( String[] args ) { 
Note: See TracChangeset for help on using the changeset viewer.