Transcript Rangkaian Komputer TK6383

Socket-based ClientServer Application
Client-Server application architecture
Choosing services – Connectionless
atau Connection-oriented
[email protected]
1
Evolution of Application Architecture
[email protected]
2
3-tier Client-server application
architecture
[email protected]
3
Internet Protocol and Network
Application

Internet protocol supports:



General-purpose service for reliable data transmission
Mechanism for connecting hosts
Network application programs:


Use Internet Protocol to connect to other application
Provide user-level services
[email protected]
4
Client-Server Model

Server Application acts as a “listener”




Waits for incoming messages
Executes services
Returns the results/outcomes
Client Application makes connection


Sends messages to the server
Waits for response
[email protected]
5
Features of a Client






An application program
 Becomes a client when a network service
is needed
 It can also executes other calculation
Is directly created by the users
Is executed locally by at the users’ computer
Initiates connection to a server
Able to access various services (at a given
time)
Does not require a special device or
operating system
[email protected]
6
Features of a Server




Special-purpose application for providing
a network service
Is executed on a remote computer
(usually is centralised and shared)
Waits and receives request for services
from the clients
Requires high-performance device and
operating system
[email protected]
7
Transport Protocol and ClientServer


Client and server exchange messages via
transport protocol such as TCP or UDP
Both client and server must have the same
protocol stack and both interact with the
transport layer
[email protected]
8
Transport Protocol and ClientServer
[email protected]
9
Several Services on a Server
[email protected]
10
Identifying a Service


Every service has a unique identifier which is used by
the client and server
Example - TCP uses port number protocol
(port_num) as identifier
 Server is registered under a specific port number
for a service
 Client asks for a session with the port number for
the service
 Every transport session contains 2 unique
indentifier
 (IP address, port number) at the server
 (IP address, port number) at the client
[email protected]
11
Connection-oriented and
Connectionless Transport Protocol


Which one should be chosen?
UDP - connectionless





Client builds a message
Client sends the message to a server
The server responds
Message must be loaded into a UDP datagram
TCP - connection-oriented



Client makes a connection to a server
Client and server exchange messages
Client terminates the connection
[email protected]
12
UDP


UDP is a connectionless transport protocol,
i.e. it doesn't guarantee either packet
delivery or that packets arrive in sequential
order.
With UDP, bytes of data are grouped
together in discrete packets which are sent
over the network.
[email protected]
13



Packets may travel along different paths
depending on the state of the network.
No two packets are guaranteed the same
route.
Each packet has a time-to-live (TTL)
counter, which is updated when it is routed
along to the next point in the network.
When the timer expires, it will be discarded,
and the recipient will not be notified.
[email protected]
14

If a packet does arrive, it will always arrive
intact. Packets that are corrupt or only
partially delivered are discarded.
[email protected]
15
Advantages of UDP



UDP communication can be more efficient
than guaranteed-delivery data streams.
Unlike TCP streams, which establish a
connection, UDP causes fewer overheads.
Real-time applications that demand up-tothe-second or better performance may be
candidates for UDP, as there are fewer
delays due to error checking and flow
control of TCP.
[email protected]
16


UDP sockets can receive data from more
than one host machine.
Some network protocols specify UDP as the
transport mechanism.
[email protected]
17
Java Support for UDP

Two classes are provided:


DatagramPacket class (java.net)
DatagramSocket class (java.net)
[email protected]
18
DatagramPacket Class



A DatagramPacket object represents a
data packet intended for transmission using
UDP.
It contains addressing information such as
an IP address and a port.
When a DatagramPacket is read from a
UDP socket, the IP address/port number of
the packet represents the address/port
number of the sender.
[email protected]
19

When a DatagramPacket is used to send
a UDP packet, the IP address/port
represents the address/port of the recipient.
DatagramPacket
IP address (java.net.InetAddr)
Port address (int)
Packet data (byte[])
[email protected]
20
Creating a DatagramPacket

Constructor to use for creating a
DatagramPacket for receiving incoming UDP
packets:
DatagramPacket(byte[] buffer, int length)

Example:
DatagramPacket packet;
packet = new DatagramPacket(new byte[256], 256);
[email protected]
21

Constructor to use for sending a
DatagramPacket to a remote machine
DatagramPacket(byte[] buffer, int length,
InetAddress dest_addr,
int dest_port)

Example:
DatagramPacket packet;
InetAddress addr;
addr = InetAddress.getByName("192.168.0.1");
packet = new DatagramPacket(new byte[128],
128,addr, 2000);
[email protected]
22
DatagramPacket Methods








InetAddress getAddress()
byte[] getData()
int getLength()
int getPort()
void setAddress(InetAddress addr)
void setData(byte[] buffer)
void setLength(int length)
void setPort(int port)
[email protected]
23
DatagramSocket Class



The DatagramSocket class provides
access to a UDP socket, which allows UDP
packets to be sent and received.
The same DatagramSocket can be used
to receive as well as to send packets.
Read operations are blocking - i.e. the
application will continue to wait until a
packet arrives.
[email protected]
24


Each DatagramSocket binds to a port on
the local machine. The port number need
not match the port number of the remote
machine.
If the application is a UDP server, it will
usually bind to a specific port number.
[email protected]
25
Creating a DatagramSocket

Constructor to use for creating a client
DatagramSocket:
DatagramSocket() throws java.net.SocketException

Example:
DatagramSocket socket;
try {
socket = new DatagramSocket();
} catch (SocketException exception) {
…
}
[email protected]
26

Constructor to use for creating a server
DatagramSocket:
DatagramSocket(int port) throws
java.net.SocketException

Example:
DatagramSocket socket;
try {
socket = new DatagramSocket(2000);
} catch (SocketException exception) {
…
}
[email protected]
27
DatagramSocket Methods

void close()
void connect(InetAddress r_addr, int r_port)
void disconnect()
InetAddress getInetAddress()
int getPort()
InetAddress getLocalAddress()
int getLocalPort()

int getReceiveBufferSize() throws java.net.SocketException






[email protected]
28

int getSendBufferSize() throws java.net.SocketException

int getSoTimeout() throws java.net.SocketException
void receive(DatagramPacket packet) throws
java.io.IOException
void send(DatagramPacket packet) throws
java.io.IOException
int setReceiveBufferSize(int length) throws
java.net.SocketException
int setSendBufferSize(int length) throws
java.net.SocketException
void setSoTimeout(int duration) throws
java.net.SocketException





[email protected]
29
Listening for UDP Packets

Before an application can read UDP
packets, it must


bind a socket to a local UDP port using
DatagramSocket
create a DatagramPacket that will contain the
data.
[email protected]
30
Packet
Reads packets
DatagramSocket
DatagramPacket
Translates packets
Into a DatagramPacket
UDP application
[email protected]
31

The following code illustrates the process
for reading UDP packets.
DatagramPacket packet;
DatagramSocket socket;
packet = new DatagramPacket(new byte[256], 256);
socket = new DatagramSocket(2000);
boolean finished = false;
while (!finished) {
socket.receive(packet);
// process the packet
}
socket.close();
[email protected]
32

Java I/O streams are usually used to
access the contents of the byte array in a
DatagramPacket. See example later.
DatagramPacket
ByteArrayInputStream
IP address (java.net.InetAddr)
Port address (int)
DataInputStream
Packet data (byte[])
[email protected]
UDP
application
33
Sending UDP Packets


When sending a packet, the application
must create a DatagramPacket that will
contain the data. The address and port
information must also be set.
When the packet is ready for transmission,
the send method of DatagramSocket
should be invoked.
[email protected]
34
DatagramSocket
Binds to a
UDP port
UDP application
Send DatagramPacket
using DatagramSocket
Packet
Constructs
packet
DatagramPacket
[email protected]
35

The following code illustrates the process
for sending UDP packets.
DatagramPacket packet;
DatagramSocket socket;
packet = new DatagramPacket(new byte[256], 256);
socket = new DatagramSocket(2000);
packet.setAddress(…);
packet.setPort(2000);
boolean finished = false;
while (!finished) {
// write data to packet buffer
socket.send(packet);
…
}
socket.close();
[email protected]
36
User Datagram Protocol Example

Run receiving application
java PacketReceiveDemo

Run sending application
java PacketSendDemo
[email protected]
37
[email protected]
38
[email protected]
39
[email protected]
40
[email protected]
41
PacketSendDemo
print(str)
PrintStream
DatagramPacket
ByteArrayOutputStream
toByteArray()
send(packet)
DatagramSocket
[email protected]
42
DatagramSocket
receive(packet)
DatagramPacket
getData()
ByteArrayInputStream
read()
PacketReceiveDemo
[email protected]
43
Building a UDP Client/Server

Run echo server
java EchoServer

Run echo client
java EchoClient
[email protected]
44
Algorithm for Echo Server
1.
2.
3.
Create socket
Create an empty packet
Repeat the following forever
1.
2.
Wait for a packet
Send the packet back to sender
[email protected]
45
Algorithm for Echo Client
Create socket
Set timeout value for socket
Repeat the following ten times
1.
2.
3.
1.
2.
3.
4.
5.
Create the message to be sent
Create packet containing the message as well as the
destination IP and the port
Send the packet through socket
Wait for packet from receiver through socket or timeout
if packet received
1.
2.
6.
Create an input stream to access data in the packet
Use the input stream to read the data and then display it on
the screen.
Sleep for a second
[email protected]
46
Overcoming UDP Limitations

UDP limitations:
 Lack of Guaranteed Delivery
 Lack of Guaranteed Packet Sequencing
 Lack of Flow Control
[email protected]
47
Lack of Guaranteed Delivery




Packets sent via UDP may become lost in
transit.
UDP packets can also become damaged or
lost.
For some applications, the loss of individual
packets may not have a noticeable effect
(e.g. video streams).
For other applications, loss of packets is not
acceptable (e.g. file transfers).
[email protected]
48

If guaranteed delivery is required,
 avoid packet-based communication, and
use a more suitable transport mechanism
(e.g. TCP).
 send acknowledgement to sender after
receiving packets.
[email protected]
49
Lack of Guaranteed Packet
Sequencing


Applications that require sequential access
to data should include a sequence number
in the contents of a datagram packet.
This enables detection of duplicate packets
and also missing packets.
[email protected]
50
Lack of Flow Control


The technique of flow control is important to
avoid flooding a system with more data than
it can handle due to limited bandwidth.
One technique of flow control is to limit the
number of unacknowledged packets. E.g.:
increase control when number of
acknowledgement packets received is
much less than the number of packets sent.
[email protected]
51
Transmission
Control Protocol
[email protected]
52
Overview


Unlike UDP which is concerned with the
transmission of packets of data, TCP
establishes a "virtual connection" between
two machines through which streams of
data may be sent.
TCP guarantees delivery and order,
providing a reliable byte communication
stream between client and server that
supports two-way communication.
[email protected]
53
Establish a virtual connection
Transmit data back and forth
Terminate the connection
[email protected]
54



TCP uses IP (Internet Protocol) to establish
the connection between machines.
This connection provides an interface that
allows streams of bytes to be sent and
received, and transparently converts the
data into IP datagram packets.
The virtual connection between two
machines is represented by a socket.
[email protected]
55

TCP sockets are different from UDP
sockets:


TCP sockets are connected to a single machine.
UDP sockets only send and receive packets of
data. TCP allows tansmission of data through
byte streams. They are converted into datagram
packets for transmission over the network without
programmer intervention.
[email protected]
56
Advantages of TCP over UDP

Automatic Error Control


Data transmission is more dependable. Delivery
of data is guaranteed - lost data packets are
retransmitted.
By means of a timer, TCP retransmits a packet if
an acknowledgement is not received from the
recipient within a specified amount of time.
[email protected]
57

Reliability

As packets are delivered by IP, they will
frequently arrive out of order. However, each
packet contains a sequence number. Using this
sequence number and queuing out-of-order
packets, TCP is able to pass arriving packets to
the application in the correct sequence.
[email protected]
58

Ease of Use

Network programmers will find programming
communication via TCP sockets far simpler than
via datagram packets. This is because data sent
and received can be treated as a continuous
stream (like I/O streams). The data need not be
packaged into discrete units like UDP.
[email protected]
59
Communication Using Ports


Both UDP and TCP uses the concept of a
communications port, which distinguishes
one application from another.
When a TCP socket establishes a
connection to another machine, the
following information will be required:


the IP address of the remote machine
the port number
[email protected]
60


Like ports in UDP, ports in TCP are also
represented by a number in the range 1 65535.
Ports below 1024 are restricted to use by
well-known services. For example,




Telnet (port 23)
SMTP (port 25)
HTTP (port 80)
POP3 (port 110)
[email protected]
61
Socket Operations

TCP sockets can perform a variety of
operations:




Establish a connection to a remote host
Send data to a remote host
Receive data from a remote host
Close a connection
[email protected]
62

There is a special type of socket that
provides a service that will bind to a specific
port number. Normally used only in
servers, this socket can perform the
following operations:



Bind to a local port
Accept incoming connections from remote hosts
Unbind from a local port
[email protected]
63
TCP and the Client/Server Paradigm



In network programming, applications that
use sockets are divided into clients and
servers.
A client is software that initiates a
connection and sends requests.
A server is software that listens for
connections and processes requests.
[email protected]
64


Note that in the context of UDP
programming, no actual connection is
established. UDP applications may both
initiate and receive requests on the same
socket.
In the client/server paradigm, when there is
a connection between two applications, one
must be a client and the other must be a
server.
[email protected]
65
Network Clients



Network clients initiate connections and
control network transactions.
The server fulfills the requests of the client
but not the other way round.
The network client speaks to the server
using a network protocol. E.g an HTTP
client communicates with an HTTP server
using HTTP.
[email protected]
66

Port numbers are used to enable clients to
locate servers. E.g. a web server uses port
80.
[email protected]
67
Network Servers



The role of the network server is to bind to a
specific port and to listen for new
connections.
Unlike the client, the server must run
continually in the hope that some client will
want its services.
The server runs indefinitely. Normally, it is
automatically started when the host
computer of the server is started.
[email protected]
68



Some servers can handle only one
connection at a time, while others can
handle many connections concurrently,
through the use of threads.
Some protocols (e.g. HTTP/1.0) normally
allow only one request per connection.
Others, like POP3, support a sequence of
requests.
Servers answer the client request by
sending either a response or an error
message.
[email protected]
69
TCP Sockets and Java

Java provide the following classes for TCP
sockets:




java.net.Socket
java.net.ServerSocket
The Socket class should be used when
writing client software.
The ServerSocket class should be used
when writing server software.
[email protected]
70
Socket Class

Socket objects represent client sockets,
and is a communication channel between
two TCP communications ports belonging
to one or two machines.
[email protected]
71


There are several constructors for the Socket
class.
The easiest way to create a socket is shown
below:
Socket mySocket;
try {
mySocket = new Socket("www.aol.com", 80);
} catch (Exception e) {
…
}
[email protected]
72

Some of the other constructors:

Socket(InetAddress addr, int port)


Socket(InetAddress rAddr, int rPort,
InetAddress lAddr, int lPort)


Throws java.io.IOException,
java.lang.SecurityException
Throws java.io.IOException,
java.lang.SecurityException
Socket(String rHost, int rPort,
InetAddress lAddr, int lPort)

Throws java.net.UnknownHostException,
java.io.IOException,
java.lang.SecurityException
[email protected]
73
Using a Socket

Refer section 6.4.2 (pg 150) for a
description of some of the methods of the
Socket class.
[email protected]
74
Reading from and Writing to TCP
Sockets

In Java, once a socket is created, it is
connected and ready to read/write by using
the socket's input and output streams. Use
the methods getInputStream() and
getOutputStream() to access those
streams.
[email protected]
75
 Example:
Socket socket;
InputStreamReader isr;
BufferedReader br;
PrintStream ps;
try {
socket = new Socket("www.aol.com",80);
isr = new
InputStreamReader(socket.getInputStream());
br = new BufferedReader(isr);
ps = new PrintStream(socket.getOutputStream());
} catch (Exception e) {
…
}
[email protected]
76
SO_TIMEOUT Socket Option


Socket options are settings that modify how
sockets work. They can affect the performance of
applications.
SO_TIMEOUT is the most useful socket option. It
allows a timer to be started when a read request is
made on a socket. When no data arrives in time
and the timer expires, a
java.io.InterruptedIOException is thrown
which can be caught to check for a timeout.
[email protected]
77
the setSoTimeout() method to set
the duration of the timer. Example:
 Use
socket.setSoTimeout(5000);
 The getSoTimeout()
method can be
used to get the duration of the timer. A
value of zero means that timeouts are
disabled and read operations will block
indefinitely.
[email protected]
78
Creating a TCP Server

The given example is a TCP server which
returns the current day and time to the
client.
[email protected]
79
SocketServer Class



The server socket is a special type of
socket used to provide TCP services.
Client sockets bind to any free port on the
local machine, and connect to a specific
port and host.
The difference with server sockets is that
they bind to a specific port on the local
machine so that remote clients may locate a
service.
[email protected]
80
 Client
socket connections will connect to
only one machine, whereas server
sockets are capable of fulfilling the
requests of multiple clients.
[email protected]
81
Creating a ServerSocket



Once a server socket is created, it will be
bound to a local port and ready to accept
incoming connections.
When clients attempt to connect, they are
placed into a queue.
When this queue is full, further clients are
refused.
[email protected]
82

There are several constructors for the
ServerSocket class.

The easiest way to create a socket is shown
below:
ServerSocket mySocket;
try {
mySocket = new ServerSocket(80);
} catch (Exception e) {
…
}
[email protected]
83

Some of the other constructors:

ServerSocket(int port)

Throws java.io.IOException,
java.lang.SecurityException
If port is 0, then any free port will be used.

By default, the queue size is set to 50.


ServerSocket(int port, int maxClients)


Throws java.io.IOException,
java.lang.SecurityException
Allocates sufficient space to the queue to support the
specified number of client sockets.
[email protected]
84
Using a ServerSocket

Refer section 6.6.2 (pg 161-Reilly) for a
description of some of the methods of the
ServerSocket class.

The most important method is the
accept() method, which accepts client
connection requests.
[email protected]
85
Accepting and Processing Requests
from TCP Clients


The most important function of a server socket is
to accept client sockets. Once a client socket is
obtained, the server can perform all the "real work"
of server programming, which involves reading
from and writing to the socket to implement a
network protocol.
Example: a mail server that provides access to
stored messages would listen to commands and
send back message contents.
[email protected]
86
 Example:
ServerSocket server;
BufferedReader reader;
PrintWriter writer;
server = new ServerSocket(13);
while (true) {
Socket client = server.accept();
reader = new BufferedReader(
new InputStreamReader(
client.getInputStream()));
writer = new PrintWriter(
new OutputStreamWriter(
client.getOutputStream()));
…
}
[email protected]
87
TCP Socket Client-Server :
ALI BABA…
[email protected]
88
ALI BABA Client-Server
[email protected]
89
Client Application


In this example, there are 2 java programs
The client program is implemented as a
class NyietInSengClient
[email protected]
90
import java.io.*;
import java.net.*;
BufferedReader stdIn = new
BufferedReader(new
InputStreamReader(System.in));
String fromServer;
String fromUser;
public class NyietInSengClient {
public static void main(String[] args)
throws IOException {
Socket nisSocket = null;
PrintWriter out = null;
BufferedReader in = null;
while ((fromServer = in.readLine()) != null) {
System.out.println("Server: " +
fromServer);
if (fromServer.equals("tata titi tutu"))
break;
try {
nisSocket = new Socket("localhost", 8888);
out = new
PrintWriter(nisSocket.getOutputStream(), true);
in = new BufferedReader(new
InputStreamReader(nisSocket.getInputStream()));
} catch (UnknownHostException e) {
System.err.println("Don't know about host:
localhost.");
System.exit(1);
} catch (IOException e) {
System.err.println("Couldn't get I/O for the
connection to: localhost.");
System.exit(1);
}
fromUser = stdIn.readLine();
if (fromUser != null) {
System.out.println("Client: " +
fromUser);
out.println(fromUser);
}
}
out.close();
in.close();
stdIn.close();
nisSocket.close();
}
}
[email protected]
91
Server Application

Server application is implemented using 2
classes:

NyietInSengServer

NyietInSengServer contains method main() for
the server program. It listens at a port for incoming
connection, accept the connection and reads
messages from client/writes responses to the
client through a socket
[email protected]
92
PrintWriter out = new
PrintWriter(clientSocket.getOutputStream(), true);
BufferedReader in = new BufferedReader(
new
InputStreamReader(clientSocket.getInputStream()
));
String inputLine, outputLine;
NyietInSengProtocol nis = new
NyietInSengProtocol();
import java.net.*;
import java.io.*;
public class NyietInSengServer {
public static void main(String[] args) throws
IOException {
ServerSocket serverSocket = null;
try {
serverSocket = new ServerSocket(8888);
} catch (IOException e) {
System.err.println("Could not listen on
port: 8888.");
System.exit(1);
}
Socket clientSocket = null;
try {
clientSocket = serverSocket.accept();
} catch (IOException e) {
System.err.println("Accept failed.");
System.exit(1);
}
outputLine = nis.processInput(null);
out.println(outputLine);
while ((inputLine = in.readLine()) != null) {
outputLine = nis.processInput(inputLine);
out.println(outputLine);
if (outputLine.equals("tata titi tutu"))
break;
}
out.close();
in.close();
clientSocket.close();
serverSocket.close();
}
}
[email protected]
93
Protocol class (part of server app)

NyietInSengProtocol


NyietInSengProtocol provides the jokes. It tracks
the current joke, the current status
(SENTTOKTOK, SENTCLUE, etc) and returns
joke text based on the current status.
It implements a communication protocol (a
language) agreed by the client and server.
[email protected]
94
Server App.
Begins by creating a ServerSocket object to listen
(wait) at a certain port. When selecting a port no., pick
one that is not reserved for other services.
 NyietInSengServer waits at port 8888 as the port 8888
is not used in my computer environment:
try {
serverSocket = new ServerSocket(8888);
}
catch (IOException e) {
System.out.println("Could not listen on port: 8888");
System.exit(-1);
}

[email protected]
95
Server App.


The constructor for ServerSocket throws
an exception if it fail to listen the specified
port (say if it is being used)
In this case NyietInSengServer has no
other choice than to exit.
[email protected]
96

If the server is able to connect to the specified
port, then a ServerSocket object is created and
the server app. Will perform the following steps
– accept connection from client (in bold):
Socket clientSocket = null;
try {
clientSocket = serverSocket.accept();
} catch (IOException e) {
System.out.println("Accept failed: 8888");
System.exit(-1);
}
[email protected]
97
Server App.





Method accept() waits until a client program is executed
and requesting for connection at a specified host and
port (example, host : localhost and port : 8888.
When connection between the client and server is
succesfully created, method accept() will return a new
Socket object (in example :clientSocket) which is bound
to a new port.
NyietInSengServer can communicate with
NyietInSengClient through this new socket.
It can keep listening and waiting for new incoming
connection using the original ServerSocket (in example
: serverSocket)
However, in the example, the server application is not
able to cater for more than 1 client.
[email protected]
98
Read/Write Process
1.
Gets the socket's input and output stream
and opens readers and writers on them
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(),
true);
BufferedReader in = new BufferedReader( new InputStreamReader(
clientSocket.getInputStream()));
String inputLine, outputLine;
[email protected]
99
Server App.

After the server successfully establishes a
connection with a client, it communicates
with the client using this code:

// initiate conversation with client
NyietInSengProtocol nis = new NyietInSengProtocol();
outputLine = nis.processInput(null);
out.println(outputLine);
2.
Initiates communication with the client by
writing to the socket (shown in bold).
[email protected]
100
Server App.
while ((inputLine = in.readLine()) != null) {
outputLine = nis.processInput(inputLine);
out.println(outputLine);
if outputLine.equals(“tata titi tutu"))
break;
}
3. Communicates with the client by reading
from and writing to the socket (the while
loop).
[email protected]
101



1 is already familiar. Step 2 is shown in bold and
is worth a few comments.
After the NyietInSengProtocol is created, the code
calls NyietInSengProtocol 's processInput method
to get the first message that the server sends to
the client.
For this example, the first thing that the server
says is “NyietInSeng MatekAji Semar Ngiseng!"
Next, the server writes the information to the
PrintWriter connected to the client socket, thereby
sending the message to the client.
[email protected]
102
Communication Protocol of AliBaba
Client-Server

Following is the implementation of the
protocol:
[email protected]
103
import java.net.*;
import java.io.*;
public class NyietInSengProtocol {
private static final int WAITING = 0;
private static final int SENTTOKTOK = 1;
private static final int SENTCLUE = 2;
private static final int ANOTHER = 3;
private static final int NUMJOKES = 3;
private int state = WAITING;
private int currentJoke = 0;
private String[] clues =
{ "Ali", "Di Sini", "Hari"};
private String[] answers =
{ "Ali Baba, Bujang Lapok la.. ",
"Di Sini lah, Oi Di Sana! ",
"Harimau Kuat! Grrrrrr "};
public String processInput(String theInput) {
String theOutput = null;
if (state == WAITING) {
theOutput = "NyietInSeng MatekAji Semar Ngiseng!";
state = SENTTOKTOK;
} else if (state == SENTTOKTOK) {
if (theInput.equalsIgnoreCase("Siapa tu?")) {
theOutput = clues[currentJoke];
state = SENTCLUE;
} else {
theOutput = "Sepatutnya awak cakap \"Siapa tu?\"! " +
"Cuba lagi. NyietInSeng MatekAji Semar
Ngiseng!";
}
} else if (state == SENTCLUE) {
if (theInput.equalsIgnoreCase(clues[currentJoke] + " mana?")) {
theOutput = answers[currentJoke] + " Main lagi? (y/n)";
state = ANOTHER;
} else {
theOutput = "Sepatutnya awak cakap \"" +
clues[currentJoke] +
" mana?\"" +
"! Cuba lagi. NyietInSeng MatekAji Semar
Ngiseng!";
state = SENTTOKTOK;
}
} else if (state == ANOTHER) {
if (theInput.equalsIgnoreCase("y")) {
theOutput = "NyietInSeng MatekAji Semar Ngiseng!";
if (currentJoke == (NUMJOKES - 1))
currentJoke = 0;
else
currentJoke++;
state = SENTTOKTOK;
} else {
theOutput = "tata titi tutu";
state = WAITING;
}
}
return theOutput;
}
}
[email protected]
104