31 	private final TickHandler tickHandler;

    62 	private TickHandler tickHandler;

    34 

    65 	

    35 	/**

    66 	private GameConnection(GameconnPtr conn, Netplay netplay) {

    36 	 * The actual connection has to be set up on a separate thread because networking

    67 		this.conn = conn;

    37 	 * is not allowed on the UI thread, so the port can't be queried immediately after

    68 		this.port = Flib.INSTANCE.flib_gameconn_getport(conn);

    38 	 * creating the GameConnection object. Instead, one of these interface methods is

    39 	 * called once we know which port we are listening on (or once we fail to set this up).

    40 	 * Methods will be called on the UI thread.

    41 	 */

    42 	public static interface Listener {

    43 		/**

    44 		 * We are listening for the engine at $port, go start the engine.

    45 		 */

    46 		void gameConnectionReady(int port);

    47 		

    48 		/**

    49 		 * The connection has stopped, either because the game has ended or was interrupted,

    50 		 * or maybe we failed to create the connection at all (in that case gameConnectionReady wasn't called).

    51 		 */

    52 		void gameConnectionDisconnected(int reason);

    53 	}

    54 	

    55 	private GameConnection(Netplay netplay) {

    57 		thread = new HandlerThread("IPCThread");

    70 		this.thread = new HandlerThread("IPCThread");

    59 		handler = new Handler(thread.getLooper());

    72 		this.handler = new Handler(thread.getLooper());

    60 		tickHandler = new TickHandler(thread.getLooper(), 50, new Runnable() {

    73 	}

    61 			public void run() {

    74 	

    62 				if(conn != null) {

    75 	private void setupConnection() {

    63 					Flib.INSTANCE.flib_gameconn_tick(conn);

    76 		tickHandler = new TickHandler(thread.getLooper(), 50, tickCb);

    64 				}

    65 			}

    66 		});

    68 	}

    78 		

    69 	

    79 		if(netplay != null) {

    70 	public static GameConnection forNetgame(final GameConfig config, Netplay netplay, final Listener listener) {

    71 		final GameConnection result = new GameConnection(netplay);

    72 		final String playerName = netplay.getPlayerName();

    73 		result.handler.post(new Runnable() {

    74 			public void run() {

    75 				GameconnPtr conn = Flib.INSTANCE.flib_gameconn_create(playerName, GameSetupPtr.createJavaOwned(config), true);

    76 				result.setupConnection(conn, true, listener);

    77 			}

    78 		});

    79 		return result;

    80 	}

    81 	

    82 	public static GameConnection forLocalGame(final GameConfig config, final Listener listener) {

    83 		final GameConnection result = new GameConnection(null);

    84 		result.handler.post(new Runnable() {

    85 			public void run() {

    86 				GameconnPtr conn = Flib.INSTANCE.flib_gameconn_create("Player", GameSetupPtr.createJavaOwned(config), false);

    87 				result.setupConnection(conn, false, listener);

    88 			}

    89 		});

    90 		return result;

    91 	}

    92 	

    93 	// runs on the IPCThread

    94 	private void setupConnection(GameconnPtr conn, final boolean netgame, final Listener listener) {

    95 		if(conn == null) {

    96 			mainHandler.post(new Runnable() {

    97 				public void run() { listener.gameConnectionDisconnected(Frontlib.GAME_END_ERROR); }

    98 			});

    99 			shutdown();

   100 		} else {

   101 			this.conn = conn;

   102 			final int port = Flib.INSTANCE.flib_gameconn_getport(conn);

   105 					listener.gameConnectionReady(port);

    82 					netplay.registerGameMessageListener(gameMessageListener);

   106 					if(netgame) {

    83 				}

   107 						netplay.registerGameMessageListener(gameMessageListener);

    84 			});

   108 					}

    85 			Flib.INSTANCE.flib_gameconn_onChat(conn, chatCb, null);

   109 				}

    86 			Flib.INSTANCE.flib_gameconn_onEngineMessage(conn, engineMessageCb, null);

   110 			});

    87 		}

   111 			Flib.INSTANCE.flib_gameconn_onConnect(conn, connectCb, null);

    88 		Flib.INSTANCE.flib_gameconn_onConnect(conn, connectCb, null);

   112 			Flib.INSTANCE.flib_gameconn_onDisconnect(conn, disconnectCb, null);

    89 		Flib.INSTANCE.flib_gameconn_onDisconnect(conn, disconnectCb, null);

   113 			Flib.INSTANCE.flib_gameconn_onErrorMessage(conn, errorMessageCb, null);

    90 		Flib.INSTANCE.flib_gameconn_onErrorMessage(conn, errorMessageCb, null);

   114 			if(netgame) {

    91 	}

   115 				Flib.INSTANCE.flib_gameconn_onChat(conn, chatCb, null);

    92 	

   116 				Flib.INSTANCE.flib_gameconn_onEngineMessage(conn, engineMessageCb, null);

    93 	/**

   117 			}

    94 	 * Start a new IPC server to communicate with the engine.

   118 		}

    95 	 * Performs networking operations, don't run on the UI thread.

   119 	}

    96 	 * @throws ConnectException if we can't set up the IPC server

    97 	 */

    98 	public static GameConnection forNetgame(final GameConfig config, Netplay netplay) throws ConnectException {

    99 		final String playerName = netplay.getPlayerName();

   100 		GameconnPtr conn = Flib.INSTANCE.flib_gameconn_create(playerName, GameSetupPtr.createJavaOwned(config), true);

   101 		if(conn == null) {

   102 			throw new ConnectException();

   103 		}

   104 		GameConnection result = new GameConnection(conn, netplay);

   105 		result.setupConnection();

   106 		return result;

   107 	}

   108 	

   109 	/**

   110 	 * Start a new IPC server to communicate with the engine.

   111 	 * Performs networking operations, don't run on the UI thread.

   112 	 * @throws ConnectException if we can't set up the IPC server

   113 	 */

   114 	public static GameConnection forLocalGame(final GameConfig config) throws ConnectException {

   115 		GameconnPtr conn = Flib.INSTANCE.flib_gameconn_create("Player", GameSetupPtr.createJavaOwned(config), false);

   116 		if(conn == null) {

   117 			throw new ConnectException();

   118 		}

   119 		GameConnection result = new GameConnection(conn, null);

   120 		result.setupConnection();

   121 		return result;

   122 	}

   123 	

   124 	private final Runnable tickCb = new Runnable() {

   125 		public void run() {

   126 			Flib.INSTANCE.flib_gameconn_tick(conn);

   127 		}

   128 	};

   182 					shutdown();

   192 					Flib.INSTANCE.flib_gameconn_send_quit(conn);