36 import android.content.res.Resources;

    38 import android.os.HandlerThread;

    45 import com.sun.jna.Pointer;

    75 	private int foregroundUsers = 0;	// Reference counter of clients requesting foreground tick speed (fast ticks)

    76 	private boolean chief;				// Do we control the current room?

   245 		public static final int MSG_LOBBY_JOIN = 0;

   246 		public static final int MSG_LOBBY_LEAVE = 1;

   247 		public static final int MSG_ROOM_JOIN = 2;

   248 		public static final int MSG_ROOM_LEAVE = 3;

   249 		public static final int MSG_CHAT = 4;

   250 		public static final int MSG_MESSAGE = 5;

   251 		public static final int MSG_ROOM_ADD = 6;

   252 		public static final int MSG_ROOM_UPDATE = 7;

   253 		public static final int MSG_ROOM_DELETE = 8;

   254 		public static final int MSG_ROOMLIST = 9;

   255 		public static final int MSG_CONNECTED = 10;

   256 		public static final int MSG_DISCONNECTED = 11;

   257 		public static final int MSG_PASSWORD_REQUEST = 12;

   258 		public static final int MSG_ENTER_ROOM_FROM_LOBBY = 13;

   259 		public static final int MSG_LEAVE_ROOM = 14;

   260 		public static final int MSG_READYSTATE = 15;

   261 		public static final int MSG_TEAM_ADDED = 16;

   262 		public static final int MSG_TEAM_DELETED = 17;

   263 		public static final int MSG_TEAM_ACCEPTED = 18;

   264 		public static final int MSG_TEAM_COLOR_CHANGED = 19;

   265 		public static final int MSG_HOG_COUNT_CHANGED = 20;

   266 		

   353 				chief = (Boolean)msg.obj;

   430 	

   431 	/**

   432 	 * This class handles the actual communication with the networking library, on a separate thread.

   433 	 */

   434 	private static class ThreadedNetConnection {

   435 		private static final long TICK_INTERVAL_FAST = 100;

   436 		private static final long TICK_INTERVAL_SLOW = 5000;

   437 		private static final Frontlib FLIB = Flib.INSTANCE;

   438 		

   439 		public final ToNetHandler toNetHandler;

   440 		

   441 		private final Context appContext;

   442 		private final FromNetHandler fromNetHandler;

   443 		private final TickHandler tickHandler;

   444 

   445 		/**

   446 		 * conn can only be null while connecting (the first thing in the thread), and directly after disconnecting,

   447 		 * in the same message (the looper is shut down on disconnect, so there will be no messages after that).

   448 		 */

   449 		private NetconnPtr conn;

   450 		private String playerName;

   451 		

   452 		private ThreadedNetConnection(Context appContext, FromNetHandler fromNetHandler) {

   453 			this.appContext = appContext;

   454 			this.fromNetHandler = fromNetHandler;

   455 			

   456 			HandlerThread thread = new HandlerThread("NetThread");

   457 			thread.start();

   458 			toNetHandler = new ToNetHandler(thread.getLooper());

   459 			tickHandler = new TickHandler(thread.getLooper(), TICK_INTERVAL_FAST, tickCb);

   460 		}

   461 		

   462 		private void connect(final String name, final String host, final int port) {

   463 			toNetHandler.post(new Runnable() {

   464 				public void run() {

   465 					playerName = name == null ? "Player" : name;

   466 					MetaschemePtr meta = null;

   467 					File dataPath;

   468 					try {

   469 						dataPath = Utils.getDataPathFile(appContext);

   470 					} catch (FileNotFoundException e) {

   471 						shutdown(true, appContext.getString(R.string.sdcard_not_mounted));

   472 						return;

   473 					}

   474 					String metaschemePath = new File(dataPath, "metasettings.ini").getAbsolutePath();

   475 					meta = FLIB.flib_metascheme_from_ini(metaschemePath);

   476 					if(meta == null) {

   477 						shutdown(true, appContext.getString(R.string.error_unexpected, "Missing metasettings.ini"));

   478 						return;

   479 					}

   480 					conn = FLIB.flib_netconn_create(playerName, meta, dataPath.getAbsolutePath(), host, port);

   481 					if(conn == null) {

   482 						shutdown(true, appContext.getString(R.string.error_connection_failed));

   483 						return;

   484 					}

   485 					FLIB.flib_netconn_onLobbyJoin(conn, lobbyJoinCb, null);

   486 					FLIB.flib_netconn_onLobbyLeave(conn, lobbyLeaveCb, null);

   487 					FLIB.flib_netconn_onRoomJoin(conn, roomJoinCb, null);

   488 					FLIB.flib_netconn_onRoomLeave(conn, roomLeaveCb, null);

   489 					FLIB.flib_netconn_onChat(conn, chatCb, null);

   490 					FLIB.flib_netconn_onMessage(conn, messageCb, null);

   491 					FLIB.flib_netconn_onRoomAdd(conn, roomAddCb, null);

   492 					FLIB.flib_netconn_onRoomUpdate(conn, roomUpdateCb, null);

   493 					FLIB.flib_netconn_onRoomDelete(conn, roomDeleteCb, null);

   494 					FLIB.flib_netconn_onConnected(conn, connectedCb, null);

   495 					FLIB.flib_netconn_onRoomlist(conn, roomlistCb, null);

   496 					FLIB.flib_netconn_onDisconnected(conn, disconnectCb, null);

   497 					FLIB.flib_netconn_onPasswordRequest(conn, passwordRequestCb, null);

   498 					FLIB.flib_netconn_onEnterRoom(conn, enterRoomCb, null);

   499 					FLIB.flib_netconn_onLeaveRoom(conn, leaveRoomCb, null);

   500 					FLIB.flib_netconn_onReadyState(conn, readyStateCb, null);

   501 					FLIB.flib_netconn_onTeamAdd(conn, teamAddedCb, null);

   502 					FLIB.flib_netconn_onTeamDelete(conn, teamDeletedCb, null);

   503 					FLIB.flib_netconn_onTeamAccepted(conn, teamAcceptedCb, null);

   504 					FLIB.flib_netconn_onTeamColorChanged(conn, teamColorChangedCb, null);

   505 					FLIB.flib_netconn_onHogCountChanged(conn, hogCountChangedCb, null);

   506 					

   507 					FLIB.flib_metascheme_release(meta);

   508 					tickHandler.start();

   509 				}

   510 			});

   511 		}

   512 		

   513 		public static ThreadedNetConnection startConnection(Context appContext, FromNetHandler fromNetHandler, String playerName, String host, int port) {

   514 			ThreadedNetConnection result = new ThreadedNetConnection(appContext, fromNetHandler);

   515 			result.connect(playerName, host, port);

   516 			return result;

   517 		}

   518 		

   519 		public void setFastTickRate(boolean fastTickRate) {

   520 			tickHandler.setInterval(fastTickRate ? TICK_INTERVAL_FAST : TICK_INTERVAL_SLOW);

   521 		}

   522 		

   523 		private final Runnable tickCb = new Runnable() {

   524 			public void run() {

   525 				FLIB.flib_netconn_tick(conn);

   526 			}

   527 		};

   528 		

   529 		private final StrCallback lobbyJoinCb = new StrCallback() {

   530 			public void callback(Pointer context, String name) {

   531 				sendFromNet(FromNetHandler.MSG_LOBBY_JOIN, name);

   532 			}

   533 		};

   534 		

   535 		private final StrStrCallback lobbyLeaveCb = new StrStrCallback() {

   536 			public void callback(Pointer context, String name, String msg) {

   537 				sendFromNet(FromNetHandler.MSG_LOBBY_LEAVE, Pair.create(name, msg));

   538 			}

   539 		};

   540 		

   541 		private final StrCallback roomJoinCb = new StrCallback() {

   542 			public void callback(Pointer context, String name) {

   543 				sendFromNet(FromNetHandler.MSG_ROOM_JOIN, name);

   544 			}

   545 		};

   546 		private final StrStrCallback roomLeaveCb = new StrStrCallback() {

   547 			public void callback(Pointer context, String name, String message) {

   548 				sendFromNet(FromNetHandler.MSG_ROOM_LEAVE, Pair.create(name, message));

   549 			}

   550 		};

   551 		private final StrStrCallback chatCb = new StrStrCallback() {

   552 			public void callback(Pointer context, String name, String msg) {

   553 				sendFromNet(FromNetHandler.MSG_CHAT, Pair.create(name, msg));

   554 			}

   555 		};

   556 		

   557 		private final IntStrCallback messageCb = new IntStrCallback() {

   558 			public void callback(Pointer context, int type, String msg) {

   559 				sendFromNet(FromNetHandler.MSG_MESSAGE, type, msg);

   560 			}

   561 		};

   562 		

   563 		private final RoomCallback roomAddCb = new RoomCallback() {

   564 			public void callback(Pointer context, RoomPtr roomPtr) {

   565 				sendFromNet(FromNetHandler.MSG_ROOM_ADD, roomPtr.deref());

   566 			}

   567 		};

   568 		

   569 		private final StrRoomCallback roomUpdateCb = new StrRoomCallback() {

   570 			public void callback(Pointer context, String name, RoomPtr roomPtr) {

   571 				sendFromNet(FromNetHandler.MSG_ROOM_UPDATE, Pair.create(name, roomPtr.deref()));

   572 			}

   573 		};

   574 		

   575 		private final StrCallback roomDeleteCb = new StrCallback() {

   576 			public void callback(Pointer context, final String name) {

   577 				sendFromNet(FromNetHandler.MSG_ROOM_DELETE, name);

   578 			}

   579 		};

   580 		

   581 		private final RoomListCallback roomlistCb = new RoomListCallback() {

   582 			public void callback(Pointer context, RoomArrayPtr arg1, int count) {

   583 				sendFromNet(FromNetHandler.MSG_ROOMLIST, arg1.getRooms(count));

   584 			}

   585 		};

   586 		

   587 		private final VoidCallback connectedCb = new VoidCallback() {

   588 			public void callback(Pointer context) {

   589 				FLIB.flib_netconn_send_request_roomlist(conn);

   590 				playerName = FLIB.flib_netconn_get_playername(conn);

   591 				sendFromNet(FromNetHandler.MSG_CONNECTED, playerName);

   592 			}

   593 		};

   594 		

   595 		private final StrCallback passwordRequestCb = new StrCallback() {

   596 			public void callback(Pointer context, String nickname) {

   597 				sendFromNet(FromNetHandler.MSG_PASSWORD_REQUEST, playerName);

   598 			}

   599 		};

   600 		

   601 		private final BoolCallback enterRoomCb = new BoolCallback() {

   602 			public void callback(Pointer context, boolean isChief) {

   603 				sendFromNet(FromNetHandler.MSG_ENTER_ROOM_FROM_LOBBY, isChief);

   604 			}

   605 		};

   606 		

   607 		private final IntStrCallback leaveRoomCb = new IntStrCallback() {

   608 			public void callback(Pointer context, int reason, String message) {

   609 				sendFromNet(FromNetHandler.MSG_LEAVE_ROOM, reason, message);

   610 			}

   611 		};

   612 		

   613 		private final StrBoolCallback readyStateCb = new StrBoolCallback() {

   614 			public void callback(Pointer context, String player, boolean ready) {

   615 				sendFromNet(FromNetHandler.MSG_READYSTATE, Pair.create(player, ready));

   616 			}

   617 		};

   618 		

   619 		private final TeamCallback teamAddedCb = new TeamCallback() {

   620 			public void callback(Pointer context, TeamPtr team) {

   621 				sendFromNet(FromNetHandler.MSG_TEAM_ADDED, team.deref().team);

   622 			}

   623 		};

   624 		

   625 		private final StrCallback teamDeletedCb = new StrCallback() {

   626 			public void callback(Pointer context, String teamName) {

   627 				sendFromNet(FromNetHandler.MSG_TEAM_DELETED, teamName);

   628 			}

   629 		};

   630 		

   631 		private final StrCallback teamAcceptedCb = new StrCallback() {

   632 			public void callback(Pointer context, String teamName) {

   633 				sendFromNet(FromNetHandler.MSG_TEAM_ACCEPTED, teamName);

   634 			}

   635 		};

   636 		

   637 		private final StrIntCallback teamColorChangedCb = new StrIntCallback() {

   638 			public void callback(Pointer context, String teamName, int colorIndex) {

   639 				sendFromNet(FromNetHandler.MSG_TEAM_COLOR_CHANGED, colorIndex, teamName);

   640 			}

   641 		};

   642 		

   643 		private final StrIntCallback hogCountChangedCb = new StrIntCallback() {

   644 			public void callback(Pointer context, String teamName, int hogCount) {

   645 				sendFromNet(FromNetHandler.MSG_HOG_COUNT_CHANGED, hogCount, teamName);

   646 			}

   647 		};

   648 		

   649 		private void shutdown(boolean error, String message) {

   650 			if(conn != null) {

   651 				FLIB.flib_netconn_destroy(conn);

   652 				conn = null;

   653 			}

   654 			tickHandler.stop();

   655 			toNetHandler.getLooper().quit();

   656 			sendFromNet(FromNetHandler.MSG_DISCONNECTED, Pair.create(error, message));

   657 		}

   658 		

   659 		private final IntStrCallback disconnectCb = new IntStrCallback() {

   660 			public void callback(Pointer context, int reason, String message) {

   661 				Boolean error = reason != Frontlib.NETCONN_DISCONNECT_NORMAL;

   662 				String messageForUser = createDisconnectUserMessage(appContext.getResources(), reason, message);

   663 				shutdown(error, messageForUser);

   664 			}

   665 		};

   666 		

   667 		private static String createDisconnectUserMessage(Resources res, int reason, String message) {

   668 			switch(reason) {

   669 			case Frontlib.NETCONN_DISCONNECT_AUTH_FAILED:

   670 				return res.getString(R.string.error_auth_failed);

   671 			case Frontlib.NETCONN_DISCONNECT_CONNLOST:

   672 				return res.getString(R.string.error_connection_lost);

   673 			case Frontlib.NETCONN_DISCONNECT_INTERNAL_ERROR:

   674 				return res.getString(R.string.error_unexpected, message);

   675 			case Frontlib.NETCONN_DISCONNECT_SERVER_TOO_OLD:

   676 				return res.getString(R.string.error_server_too_old);

   677 			default:

   678 				return message;

   679 			}

   680 		}

   681 		

   682 		private boolean sendFromNet(int what, Object obj) {

   683 			return fromNetHandler.sendMessage(fromNetHandler.obtainMessage(what, obj));

   684 		}

   685 		

   686 		private boolean sendFromNet(int what, int arg1, Object obj) {

   687 			return fromNetHandler.sendMessage(fromNetHandler.obtainMessage(what, arg1, 0, obj));

   688 		}

   689 		

   690 		/**

   691 		 * Processes messages to the networking system. Runs on a non-main thread.

   692 		 */

   693 		@SuppressLint("HandlerLeak")

   694 		public final class ToNetHandler extends Handler {

   695 			public static final int MSG_SEND_NICK = 0;

   696 			public static final int MSG_SEND_PASSWORD = 1;

   697 			public static final int MSG_SEND_QUIT = 2;

   698 			public static final int MSG_SEND_ROOMLIST_REQUEST = 3;

   699 			public static final int MSG_SEND_PLAYER_INFO_REQUEST = 4;

   700 			public static final int MSG_SEND_CHAT = 5;

   701 			public static final int MSG_SEND_FOLLOW_PLAYER = 6;

   702 			public static final int MSG_SEND_JOIN_ROOM = 7;

   703 			public static final int MSG_SEND_CREATE_ROOM = 8;

   704 			public static final int MSG_SEND_LEAVE_ROOM = 9;

   705 			public static final int MSG_SEND_KICK = 10;

   706 			public static final int MSG_SEND_ADD_TEAM = 11;

   707 			public static final int MSG_SEND_REMOVE_TEAM = 12;

   708 			public static final int MSG_DISCONNECT = 13;

   709 			public static final int MSG_SEND_TEAM_COLOR_INDEX = 14;

   710 			public static final int MSG_SEND_TEAM_HOG_COUNT = 15;

   711 			

   712 			public ToNetHandler(Looper looper) {

   713 				super(looper);

   714 			}

   715 			

   716 			@Override

   717 			public void handleMessage(Message msg) {

   718 				switch(msg.what) {

   719 				case MSG_SEND_NICK: {

   720 					FLIB.flib_netconn_send_nick(conn, (String)msg.obj);

   721 					break;

   722 				}

   723 				case MSG_SEND_PASSWORD: {

   724 					FLIB.flib_netconn_send_password(conn, (String)msg.obj);

   725 					break;

   726 				}

   727 				case MSG_SEND_QUIT: {

   728 					FLIB.flib_netconn_send_quit(conn, (String)msg.obj);

   729 					break;

   730 				}

   731 				case MSG_SEND_ROOMLIST_REQUEST: {

   732 					FLIB.flib_netconn_send_request_roomlist(conn);

   733 					break;

   734 				}

   735 				case MSG_SEND_PLAYER_INFO_REQUEST: {

   736 					FLIB.flib_netconn_send_playerInfo(conn, (String)msg.obj);

   737 					break;

   738 				}

   739 				case MSG_SEND_CHAT: {

   740 					if(FLIB.flib_netconn_send_chat(conn, (String)msg.obj) == 0) {

   741 						sendFromNet(FromNetHandler.MSG_CHAT, Pair.create(playerName, (String)msg.obj));

   742 					}

   743 					break;

   744 				}

   745 				case MSG_SEND_FOLLOW_PLAYER: {

   746 					FLIB.flib_netconn_send_playerFollow(conn, (String)msg.obj);

   747 					break;

   748 				}

   749 				case MSG_SEND_JOIN_ROOM: {

   750 					FLIB.flib_netconn_send_joinRoom(conn, (String)msg.obj);

   751 					break;

   752 				}

   753 				case MSG_SEND_CREATE_ROOM: {

   754 					FLIB.flib_netconn_send_createRoom(conn, (String)msg.obj);

   755 					break;

   756 				}

   757 				case MSG_SEND_LEAVE_ROOM: {

   758 					if(FLIB.flib_netconn_send_leaveRoom(conn, (String)msg.obj) == 0) {

   759 						sendFromNet(FromNetHandler.MSG_LEAVE_ROOM, -1, "");

   760 					}

   761 					break;

   762 				}

   763 				case MSG_SEND_KICK: {

   764 					FLIB.flib_netconn_send_kick(conn, (String)msg.obj);

   765 					break;

   766 				}

   767 				case MSG_SEND_ADD_TEAM: {

   768 					FLIB.flib_netconn_send_addTeam(conn, TeamPtr.createJavaOwned((Team)msg.obj));

   769 					break;

   770 				}

   771 				case MSG_SEND_REMOVE_TEAM: {

   772 					if(FLIB.flib_netconn_send_removeTeam(conn, (String)msg.obj)==0) {

   773 						sendFromNet(FromNetHandler.MSG_TEAM_DELETED, msg.obj);

   774 					}

   775 					break;

   776 				}

   777 				case MSG_DISCONNECT: {

   778 					FLIB.flib_netconn_send_quit(conn, (String)msg.obj);

   779 					shutdown(false, "User quit");

   780 					break;

   781 				}

   782 				case MSG_SEND_TEAM_COLOR_INDEX: {

   783 					if(FLIB.flib_netconn_send_teamColor(conn, (String)msg.obj, msg.arg1)==0) {

   784 						sendFromNet(FromNetHandler.MSG_TEAM_COLOR_CHANGED, msg.arg1, msg.obj);

   785 					}

   786 					break;

   787 				}

   788 				case MSG_SEND_TEAM_HOG_COUNT: {

   789 					if(FLIB.flib_netconn_send_teamHogCount(conn, (String)msg.obj, msg.arg1)==0) {

   790 						sendFromNet(FromNetHandler.MSG_HOG_COUNT_CHANGED, msg.arg1, msg.obj);

   791 					}

   792 					break;

   793 				}

   794 				default: {

   795 					Log.e("ToNetHandler", "Unknown message type: "+msg.what);

   796 					break;

   797 				}

   798 				}

   799 			}

   800 		}

   801 	}