Changeset 27 for chess

Timestamp:

02/06/09 09:38:29 (13 years ago)

Author:

BegemoT

Message:

fixing УВЕ blocking issue while scanning network

Location:

chess

Files:

• chess.jad (modified) (1 diff)
• src/chess/MSG.properties (modified) (1 diff)
• src/chess/Util.java (modified) (3 diffs)
• src/chess/remote/IAsyncProcess.java (modified) (1 diff)
• src/chess/remote/impl/BTRemote.java (modified) (1 diff)
• src/chess/remote/impl/BaseAsyncProcess.java (modified) (3 diffs)
• src/chess/remote/impl/debug/DebugRemote.java (modified) (2 diffs)
• src/chess/ui/ChessMIDlet.java (modified) (6 diffs)

chess/chess.jad

@@ -1 +1 @@
 MIDlet-1: Chess Game, , chess.ui.ChessMIDlet
-MIDlet-Jar-Size: 84540
+MIDlet-Jar-Size: 310674
 MIDlet-Jar-URL: chess.jar
 MIDlet-Name: Chess

chess/src/chess/MSG.properties

@@ -1 +1 @@
 command.ok=OK
+command.yes=\u0414\u0430
+command.no=\u041d\u0435\u0442
 command.exit=\u0412\u044b\u0445\u043e\u0434
 command.back=\u041d\u0430\u0437\u0430\u0434

chess/src/chess/Util.java

@@ -10 +10 @@
 import chess.remote.IRemote;
 import chess.remote.impl.BTRemote;
+import chess.remote.impl.debug.DebugRemote;
 
 
@@ -24 +25 @@
     /**
      * âêëþ÷àåò äîïîëíèòåëüíûå ïðîâåðêè íà ñòàäèè âûïîëíåíèÿ,
-     * ïðè ýòîì îòêëþ÷àòü èõ íà ñòàäèè ïîäãîòîâêè production
+     * ïðè ýòîì ìîæíî îòêëþ÷àòü èõ íà ñòàäèè ïîäãîòîâêè production
      */
     public static final boolean SAFE_MODE = true;
@@ -31 +32 @@
     public static IRemote create() throws Exception {
         return new BTRemote();
-        //return new DebugRemote( 100, 100 );
+        //return new DebugRemote( 500, 500 );
     }
 

chess/src/chess/remote/IAsyncProcess.java

@@ -9 +9 @@
         public static final int SUCCEEDED = 1;
         public static final int FAILED = 2;
+        public static final int INTERRUPTED = 3;
 
         public int status();

chess/src/chess/remote/impl/BTRemote.java

@@ -20 +20 @@
  */
 public class BTRemote implements IRemote {
-        public static final String BTSPP_SCHEME = "btspp://";
-        public static final String MY_SERVICE_NUMBER = "3B9FA89520078C303355AAA694238F08;name=ChessGameServer";
-
-        public static final IRemoteNode[] EMPTY = new IRemoteNode[0];
-
-        private final LocalDevice localDevice;
-        private final Vector devices = new Vector();
-
-        public BTRemote() throws Exception {
-                localDevice = LocalDevice.getLocalDevice();
-                fillupCache();
-        }
-
-        private synchronized void fillupCache() {
-                final DiscoveryAgent agent = localDevice.getDiscoveryAgent();
-                final RemoteDevice[] preknownDevices = agent.retrieveDevices( DiscoveryAgent.PREKNOWN );
-                if( preknownDevices != null ) {
-                        for( int i = 0; i < preknownDevices.length; i++ ) {
-                                final RemoteDevice device = preknownDevices[i];
-                                devices.addElement( device );
-                        }
-                }
-                final RemoteDevice[] cachedDevices = agent.retrieveDevices( DiscoveryAgent.CACHED );
-                if( cachedDevices != null ) {
-                        for( int i = 0; i < cachedDevices.length; i++ ) {
-                                final RemoteDevice device = cachedDevices[i];
-                                devices.addElement( device );
-                        }
-                }
-        }
-
-        private synchronized void refreshCache() {
-                devices.removeAllElements();
-                fillupCache();
-        }
-
-        public IAsyncProcess waitForIncoming( final IServerListener l ) {
-                return new WaitForIncomingThread( localDevice, l );
-        }
-
-        public IAsyncProcess getAvailable( final boolean refresh,
-                                           final IClientListener l ) {
-                if( refresh ) {
-                        try {
-                                final DiscoveryAgent agent = localDevice.getDiscoveryAgent();
-                                return new QueryDeviceProcess( this, agent, l );
-                        } catch( Exception e ) {
-                                e.printStackTrace();
-                                l.finished( null );
-                                return null;
-                        }
-                } else {
-                        final IRemoteNode[] nodes = getNodes();
-                        l.finished( nodes );
-                        return null;
-                }
-        }
-
-        private synchronized IRemoteNode[] getNodes() {
-                if( devices.isEmpty() ) {
-                        return EMPTY;
-                }
-                final int length = devices.size();
-                final IRemoteNode[] nodes = new IRemoteNode[length];
-                for( int i = 0; i < length; i++ ) {
-                        try {
-                                final RemoteDevice device = ( RemoteDevice ) devices.elementAt( i );
-                                final BTNode node = new BTNode( device );
-                                nodes[i] = node;
-                        } catch( IOException e ) {
-                                e.printStackTrace();
-                        }
-                }
-                return nodes;
-        }
-
-        private static class WaitForIncomingThread extends BaseAsyncProcess {
-                private final LocalDevice localDevice;
-                private StreamConnectionNotifier server;
-
-                public WaitForIncomingThread( final LocalDevice local,
-                                              final IServerListener listener ) {
-                        super( listener );
-                        this.localDevice = local;
-                        start();
-                }
-
-                public void run() {
-                        try {
-                                localDevice.setDiscoverable( DiscoveryAgent.GIAC );
-                                setStatus( IN_PROCESS );
-                                while( true ) {
-                                        server = ( StreamConnectionNotifier ) Connector.open(
-                                                        BTSPP_SCHEME + "localhost:" + MY_SERVICE_NUMBER,
-                                                        Connector.READ_WRITE,
-                                                        true
-                                        );
-                                        Util.log.println( "creating server and waiting for incoming" );
-                                        try {
-                                                while( true ) {
-                                                        // Îæèäàåì âõîäÿùåå ïîòîêîâîå ñîåäèíåíèå
-                                                        final StreamConnection conn = server.acceptAndOpen();
-                                                        Util.log.println( "accepted incoming:" + conn );
-                                                        final BTNode client = new BTNode( conn );
-                                                        if( listener.incoming( client ) ) {
-                                                                //åñëè êëèåíò ïðèíÿò -- âûõîäèì (èãðà äîïóñêàåò òîëüêî îäíîãî ñîïåðíèêà)
-                                                                Util.log.println( "client accepted -> close server" );
-                                                                setStatus( SUCCEEDED );
-                                                                return;
-                                                        }
-                                                        client.close();
-                                                }
-                                        } catch( InterruptedIOException ex ) {
-                                                Util.log.println( "server was closed:" + ex.getMessage() );
-                                                return;
-                                        } catch( IOException ex ) {
-                                                Util.log.println( "server got error -- trying to recreate server connection" );
-                                                ex.printStackTrace();
-                                        } finally {
-                                                if( server != null ) {
-                                                        try {
-                                                                server.close();
-                                                                server = null;
-                                                        } catch( IOException e ) {
-                                                                e.printStackTrace();
-                                                        }
-                                                }
-                                        }
-
-                                }
-                        } catch( IOException ex ) {
-                                //åñëè íå óäàëîñü îòêðûòü ñîåäèíåíèå -- ýòî ïèçäåö. óõîäèì
-                                //...íå óäàëîñü îïóáëèêîâàòü óñòðîéñòâî -- ïèçäåö, óõîäèì
-                                ex.printStackTrace();
-                                setStatus( FAILED );
-                        } finally {
-                                listener.finished( null );
-                                Util.log.println( "server stopped" );
-                        }
-                }
-
-
-                public void interrupt( final boolean waitFor ) {
-                        if( isAlive() ) {
-//                              interrupt();
-                                if( server != null ) {
-                                        try {
-                                                server.close();
-                                                server = null;
-                                        } catch( IOException e ) {
-                                                e.printStackTrace();
-                                        }
-                                }
-                                if( waitFor && Thread.currentThread() != this ) {
-                                        try {
-                                                join();
-                                        } catch( InterruptedException e ) {
-                                                e.printStackTrace();
-                                        }
-                                }
-                        }
-                }
-        }
-
-        private static class QueryDeviceProcess implements IAsyncProcess, DiscoveryListener {
-                private final DiscoveryAgent agent;
-                private final IClientListener l;
-                private final BTRemote remote;
-
-                private volatile int status = IN_PROCESS;
-
-                public QueryDeviceProcess( final BTRemote remote,
-                                           final DiscoveryAgent agent,
-                                           final IClientListener l ) throws Exception {
-                        this.remote = remote;
-                        this.agent = agent;
-                        this.l = l;
-                        agent.startInquiry( DiscoveryAgent.GIAC, this );
-                }
-
-                public int status() {
-                        return status;
-                }
-
-                public void interrupt( final boolean waitFor ) {
-                        agent.cancelInquiry( this );
-                }
-
-                public IAsyncProcessListener getListener() {
-                        return l;
-                }
-
-                public void deviceDiscovered( final RemoteDevice btDevice,
-                                              final DeviceClass cod ) {
-                        Util.log.println( "device found:" + btDevice.getBluetoothAddress() );
-                }
-
-                public void servicesDiscovered( final int transID,
-                                                final ServiceRecord[] servRecord ) {
-                        Util.log.println( "service found:" + transID );
-                }
-
-                public void serviceSearchCompleted( final int transID,
-                                                    final int respCode ) {
-
-                }
-
-                public void inquiryCompleted( final int discType ) {
-                        switch( discType ) {
-                                case INQUIRY_COMPLETED:
-                                        remote.refreshCache();
-                                        status = SUCCEEDED;
-                                        l.finished( remote.getNodes() );
-                                        break;
-                                case INQUIRY_TERMINATED:
-                                        Util.log.println( "query interrupted" );
-                                case INQUIRY_ERROR:
-                                        status = FAILED;
-                                        l.finished( null );
-                        }                       
-                }
-        }
+    public static final String BTSPP_SCHEME = "btspp://";
+    public static final String MY_SERVICE_NUMBER = "3B9FA89520078C303355AAA694238F08;name=ChessGameServer";
+
+    public static final IRemoteNode[] EMPTY = new IRemoteNode[0];
+
+    private final LocalDevice localDevice;
+    private final Vector devices = new Vector();
+
+    public BTRemote() throws Exception {
+        localDevice = LocalDevice.getLocalDevice();
+        fillupCache();
+    }
+
+    private synchronized void fillupCache() {
+        final DiscoveryAgent agent = localDevice.getDiscoveryAgent();
+        final RemoteDevice[] preknownDevices = agent.retrieveDevices( DiscoveryAgent.PREKNOWN );
+        if ( preknownDevices != null ) {
+            for ( int i = 0; i < preknownDevices.length; i++ ) {
+                final RemoteDevice device = preknownDevices[i];
+                devices.addElement( device );
+            }
+        }
+        final RemoteDevice[] cachedDevices = agent.retrieveDevices( DiscoveryAgent.CACHED );
+        if ( cachedDevices != null ) {
+            for ( int i = 0; i < cachedDevices.length; i++ ) {
+                final RemoteDevice device = cachedDevices[i];
+                devices.addElement( device );
+            }
+        }
+    }
+
+    private synchronized void refreshCache() {
+        devices.removeAllElements();
+        fillupCache();
+    }
+
+    public IAsyncProcess waitForIncoming( final IServerListener l ) {
+        return new WaitForIncomingThread( localDevice, l );
+    }
+
+    public IAsyncProcess getAvailable( final boolean refresh,
+                                       final IClientListener l ) {
+        if ( refresh ) {
+            try {
+                final DiscoveryAgent agent = localDevice.getDiscoveryAgent();
+                return new QueryDeviceProcess( this, agent, l );
+            } catch ( Exception e ) {
+                e.printStackTrace();
+                l.finished( null );
+                return null;
+            }
+        } else {
+            final IRemoteNode[] nodes = getNodes();
+            l.finished( nodes );
+            return null;
+        }
+    }
+
+    private synchronized IRemoteNode[] getNodes() {
+        if ( devices.isEmpty() ) {
+            return EMPTY;
+        }
+        final int length = devices.size();
+        final IRemoteNode[] nodes = new IRemoteNode[length];
+        for ( int i = 0; i < length; i++ ) {
+            try {
+                final RemoteDevice device = ( RemoteDevice )devices.elementAt( i );
+                final BTNode node = new BTNode( device );
+                nodes[i] = node;
+            } catch ( IOException e ) {
+                e.printStackTrace();
+            }
+        }
+        return nodes;
+    }
+
+    private static class WaitForIncomingThread extends BaseAsyncProcess {
+        private final LocalDevice localDevice;
+        private StreamConnectionNotifier server;
+
+        public WaitForIncomingThread( final LocalDevice local,
+                                      final IServerListener listener ) {
+            super( listener );
+            this.localDevice = local;
+            start();
+        }
+
+        public void run() {
+            try {
+                localDevice.setDiscoverable( DiscoveryAgent.GIAC );
+                setStatus( IN_PROCESS );
+                while ( true ) {
+                    server = ( StreamConnectionNotifier )Connector.open(
+                            BTSPP_SCHEME + "localhost:" + MY_SERVICE_NUMBER,
+                            Connector.READ_WRITE,
+                            true
+                    );
+                    Util.log.println( "creating server and waiting for incoming" );
+                    try {
+                        final IServerListener _listener = ( IServerListener )listener;
+                        while ( true ) {
+                            // Îæèäàåì âõîäÿùåå ïîòîêîâîå ñîåäèíåíèå
+                            final StreamConnection conn = server.acceptAndOpen();
+                            Util.log.println( "accepted incoming: " + conn );
+                            final BTNode client = new BTNode( conn );
+                            if ( _listener.incoming( client ) ) {
+                                //åñëè êëèåíò ïðèíÿò -- âûõîäèì (èãðà äîïóñêàåò òîëüêî îäíîãî ñîïåðíèêà)
+                                Util.log.println( "client accepted -> close server" );
+                                setStatus( SUCCEEDED );
+                                return;
+                            }
+                            client.close();
+                        }
+                    } catch ( InterruptedIOException ex ) {
+                        setStatus( INTERRUPTED );
+                        Util.log.println( "server was closed: " + ex.getMessage() );
+                        return;
+                    } catch ( IOException ex ) {
+                        Util.log.println( "server got error -- trying to recreate server connection" );
+                        ex.printStackTrace();
+                    } finally {
+                        if ( server != null ) {
+                            try {
+                                server.close();
+                                server = null;
+                            } catch ( IOException e ) {
+                                e.printStackTrace();
+                            }
+                        }
+                    }
+                }
+            } catch ( IOException ex ) {
+                //åñëè íå óäàëîñü îòêðûòü ñîåäèíåíèå -- ýòî ïèçäåö. óõîäèì
+                //...íå óäàëîñü îïóáëèêîâàòü óñòðîéñòâî -- ïèçäåö, óõîäèì
+                ex.printStackTrace();
+                setStatus( FAILED );
+            } finally {
+                listener.finished( null );
+                Util.log.println( "server stopped" );
+            }
+        }
+
+        public void interrupt( final boolean waitFor ) {
+            if ( isAlive() ) {
+                if ( server != null ) {
+                    try {
+                        server.close();
+                        server = null;
+                    } catch ( IOException e ) {
+                        e.printStackTrace();
+                    }
+                }
+                waitForThread( waitFor );
+            }
+        }
+
+    }
+
+    private static class QueryDeviceProcess extends BaseAsyncProcess implements DiscoveryListener {
+        private final DiscoveryAgent agent;
+        private final BTRemote remote;
+
+        public QueryDeviceProcess( final BTRemote remote,
+                                   final DiscoveryAgent agent,
+                                   final IClientListener listener ) {
+            super( listener );
+            this.remote = remote;
+            this.agent = agent;
+            start();
+        }
+
+        public void run() {
+            /* Íåïîíÿòíî, ÿâëÿåòñÿ ëè ýòîò çàïðîñ ñèíõðîííûì, èëè àñèíõðîííûì --
+             * äîêóìåíòàöèÿ íà ýòîò ñ÷åò ìîë÷èò, à ïðàêòèêà ïîêàçûâàåò, ÷òî
+             * áûâàåò è òàê è ýäàê. Ïîýòîìó ñòðàõóåìñÿ íà âñÿêèé ñëó÷àé îò
+             * íåâåäîìîé õóéíè è äåëàåì ýòî â îòäåëüíîì ïîòîêå
+             */
+            setStatus( IN_PROCESS );
+            Util.log.println( "starting query device list" );
+            try {
+                agent.startInquiry( DiscoveryAgent.GIAC, this );
+            } catch ( BluetoothStateException e ) {
+                e.printStackTrace();
+                setStatus( FAILED );
+                listener.finished( null );
+            }
+        }
+
+
+        public void interrupt( final boolean waitFor ) {
+            if ( status() == IN_PROCESS ) {
+                agent.cancelInquiry( this );
+                waitForThread( waitFor );
+            }
+        }        
+
+        public void deviceDiscovered( final RemoteDevice btDevice,
+                                      final DeviceClass cod ) {
+            Util.log.println( "device found:" + btDevice.getBluetoothAddress() );
+        }
+
+        public void servicesDiscovered( final int transID,
+                                        final ServiceRecord[] servRecord ) {
+            Util.log.println( "service found:" + transID );
+        }
+
+        public void serviceSearchCompleted( final int transID,
+                                            final int respCode ) {
+
+        }
+
+        public void inquiryCompleted( final int discType ) {
+            switch ( discType ) {
+                case INQUIRY_COMPLETED:
+                    Util.log.println( "device list query finished" );
+                    remote.refreshCache();
+                    setStatus( SUCCEEDED );
+                    listener.finished( remote.getNodes() );
+                    break;
+                case INQUIRY_TERMINATED:
+                    Util.log.println( "device list query interrupted" );
+                    setStatus( INTERRUPTED );
+                    listener.finished( null );
+                    break;
+                case INQUIRY_ERROR:
+                    Util.log.println( "device list query failed" );
+                    setStatus( FAILED );
+                    listener.finished( null );
+                    break;
+            }
+        }
+    }
 }

chess/src/chess/remote/impl/BaseAsyncProcess.java

@@ -3 +3 @@
 import chess.remote.IAsyncProcess;
 import chess.remote.IAsyncProcessListener;
-import chess.remote.IServerListener;
+import chess.Util;
 
 /**
@@ -12 +12 @@
  */
 public class BaseAsyncProcess extends Thread implements IAsyncProcess {
-    protected final IServerListener listener;
-    private volatile int status = IN_PROCESS;
+    protected final IAsyncProcessListener listener;
 
-    public BaseAsyncProcess( final IServerListener listener ) {
+    private int status = IN_PROCESS;
+
+    public BaseAsyncProcess( final IAsyncProcessListener listener ) {
         this.listener = listener;
     }
 
-    public int status() {
+    public final int status() {
         return status;
     }
 
-    protected void setStatus( final int status ) {
+    protected final synchronized void setStatus( final int status ) {
         switch ( status ) {
             case IN_PROCESS:
             case SUCCEEDED:
             case FAILED:
+            case INTERRUPTED:
                 this.status = status;
                 break;
@@ -38 +40 @@
         if ( isAlive() ) {
             interrupt();
-            if ( waitFor && Thread.currentThread() != this ) {
-                try {
-                    join();
-                } catch ( InterruptedException e ) {
-                    e.printStackTrace();
-                }
+            waitForThread( waitFor );
+        }
+    }
+
+    protected void waitForThread( final boolean waitFor ) {
+        if ( waitFor
+                && isAlive()
+                && Thread.currentThread() != this ) {
+            Util.log.println( "waiting for thread to finish" );
+            try {
+                join();
+            } catch ( InterruptedException e ) {
+                e.printStackTrace();
             }
         }
     }
 
-    public IAsyncProcessListener getListener() {
+    public final IAsyncProcessListener getListener() {
         return listener;
     }

chess/src/chess/remote/impl/debug/DebugRemote.java

@@ -113 +113 @@
             try {
                 setStatus( IN_PROCESS );
+                final IServerListener _listener = ( IServerListener )listener;
                 while ( true ) {
-                    try {
-                        synchronized ( this ) {
-                            wait( 4 * networkLatency );
-                        }
-                    } catch ( InterruptedException e ) {
-                        e.printStackTrace();
+                    synchronized ( this ) {
+                        wait( 4 * networkLatency );
                     }
-                    if ( listener.incoming( new ClientRemoteNode() ) ) {
+                    if ( _listener.incoming( new ClientRemoteNode() ) ) {
                         Util.log.println( "emulate incoming connection: OK" );
                         setStatus( SUCCEEDED );
@@ -127 +124 @@
                     }
                 }
+            } catch ( InterruptedException ex ) {
+                setStatus( INTERRUPTED );
             } catch ( Exception ex ) {
                 setStatus( FAILED );

chess/src/chess/ui/ChessMIDlet.java

@@ -26 +26 @@
     /* commands */
     public final Command okCommand = new Command( MSG.getMessage( "command.ok" ), Command.OK, 1 );
+    public final Command yesCommand = new Command( MSG.getMessage( "command.yes" ), Command.OK, 1 );
+    public final Command noCommand = new Command( MSG.getMessage( "command.no" ), Command.CANCEL, 1 );
     public final Command exitCommand = new Command( MSG.getMessage( "command.exit" ), Command.EXIT, 1 );
-    public final Command closeCommand = new Command( MSG.getMessage( "command.close" ), Command.SCREEN, 1 );
+    public final Command closeCommand = new Command( MSG.getMessage( "command.close" ), Command.STOP, 1 );
     public final Command cancelCommand = new Command( MSG.getMessage( "command.cancel" ), Command.CANCEL, 1 );
-    public final Command backCommand = new Command( MSG.getMessage( "command.back" ), Command.CANCEL, 1 );
+    public final Command backCommand = new Command( MSG.getMessage( "command.back" ), Command.BACK, 1 );
     public final Command refreshCommand = new Command( MSG.getMessage( "command.refresh" ), Command.SCREEN, 1 );
     public final Command newCommand = new Command( MSG.getMessage( "command.new" ), Command.SCREEN, 1 );
@@ -136 +138 @@
                         );
                         dlg.setTimeout( Alert.FOREVER );
-                        dlg.addCommand( okCommand );
-                        dlg.addCommand( Alert.DISMISS_COMMAND );
+                        dlg.addCommand( yesCommand );
+                        dlg.addCommand( noCommand );
+                        //dlg.removeCommand( Alert.DISMISS_COMMAND );
                         dlg.setCommandListener(
                                 new CommandListener() {
@@ -143 +146 @@
                                                                final Displayable displayable ) {
                                         try {
-                                            if ( command == okCommand ) {
-                                                Util.log.println( command );
+                                            //Util.log.println( command );
+                                            if ( command == yesCommand ) {
                                                 retValue = true;
                                             } else {
@@ -153 +156 @@
                                                 ChessMIDlet.this.notifyAll();
                                             }
+                                            display.setCurrent( waitScreen );
                                         }
                                     }
@@ -162 +166 @@
                                 ChessMIDlet.this.wait();
                             } catch ( InterruptedException e ) {
-                                e.printStackTrace();
+                                //e.printStackTrace();
                             }
                         }
@@ -183 +187 @@
 
                     public void finished( final Object res ) {
-                        //todo ask for status and display error message if failed
-                        if ( waitForIncomingProcess.status() == IAsyncProcess.SUCCEEDED ) {
-                            waitScreen.finished( res );
-                        } else {
-                            display.setCurrent( startForm );
+                        //todo display error message if failed
+                        final int status = waitForIncomingProcess.status();
+                        switch ( status ) {
+                            case IAsyncProcess.SUCCEEDED:
+                                waitScreen.finished( res );
+                                break;
+                            case IAsyncProcess.FAILED:
+                                final Alert alert = new Alert( "Error", "Error in starting server", null, AlertType.ERROR );
+                                display.setCurrent( alert, startForm );
+                                break;
+                            case IAsyncProcess.INTERRUPTED:
+                                display.setCurrent( startForm );
+                                break;
                         }
                         waitForIncomingProcess = null;