Networking and Data Access with Eqela

(3) NETWORKING AND
DATA ACCESS

NETWORK PROGRAMMING (eq.net)

eq.net.TCPSocket
In Eqela, TCP/IP sockets are implemented through
eq.net.TCPSocket
var socket = TCPSocket.create("192.168.1.1", 80);
// read and write to the socket
socket.close();

Domain Name System (DNS)
 There are two ways to convert a host name into an
IP address:
1.Using eq.net.DNSCache
Example:
1.Using eq.net.DNSResolver
Example:
or
var ip = DNSCache.resolve(hostname);
var ip = DNSResolver.get_ip_address(hostname);
var ip_coll = DNSResolver.get_ip_addresses(hostname);

Sequence of connecting a client
socket via TCP/IP
● Regardless of the operating system and
programming language, the process of connecting
a TCP/IP socket is as follows:
1.Create a socket / socket object
2.Resolve the server hostname into an IP address using
DNS
3.Establish a TCP connection to the destination host /
port
4.Read & write data

Sample socket client program
class Main : Command
{
public int main(Collection args) {
var addr = args.get_index(0) as String;
Log.message("resolve '%s' ..".printf().add(addr));
var ip = DNSCache.resolve(addr);
if(ip == null) {
Log.error("failed to resolve");
return(1);
}
Log.message("connect to '%s' ..".printf().add(ip));
var os = OutputStream.create(TCPSocket.create(ip, 80));
if(os == null) {
Log.error.("failed to connect");
return(1);
}
Log.message("sending data ..");
os.write_string("hello");
Log.message("done");
return(0);
}
}

Threading and networking
In GUI applications, you are either not allowed, or it
is not recommended, to do networking in the same
thread as the GUI
- This would freeze the user interface -
In GUI applications, networking should generally be
done in separate threads

Network threading in Eqela
class MyNetworkTask : Task {
public Object run(EventReceiver listener) {
var socket = TCPSocket.create(“64.79.194.207“, 80);
if(socket != null) {
return(“Connected”);
}
return(“Failed”);
}
}
class Main : AlignWidget, EventReceiver {
LabelWidget status;
public void initialize() {
base.initialize();
add(status = LabelWidget.for_string(“Ready”));
}
public void start() {
base.start();
status.set_text(“Processing ..”);
Task.execute(new MyNetworkTask(), this);
}
public void on_event(Object o) {
status.set_text(o as String);
}
}

Android: Permissions
To use certain platform features on the Android
platform, the application must declare the
permissions it requires
Specifically, Internet access requires permissions
Permissions can be declared in the Eqela application
config file (.config)
android_manifest_permissions: android.permission.INTERNET

Availability of TCP/IP sockets
Almost all modern operating systems / software platforms
allow the use of TCP/IP sockets ..
.. with the notable exception of the HTML5 platform
Eqela does not currently support TCP/IP sockets in HTML5
applications (only HTTP is available)
Legacy platforms (such as J2ME) may also not support TCP
sockets
To maximize compatibility, use of HTTP networking is
recommended in applications

Sequence of establishing a TCP/IP
server socket
 Regardless of the operating system and
programming language used, the sequence is the
same:
1.Create a socket / socket object
2.Bind the socket to a specific port (choose a specific
port number)
3.Start listening for incoming connections on the
socket
4.Accept connections as they come in

Sample server program
class Main : Command
{
public int main(Collection args) {
var s = TCPSocket.create();
if(s.listen(1503) == false) {
Log.error("Failed to listen");
return(1);
}
TCPSocket c;
Log.message("waiting on port 1503 ..");
while((c = s.accept()) != null) {
Log.message("received a connection");
Log.message("received: %s".printf().add(InputStream.create(c)
.read_all_string()));
}
return(0);
}
}

User Datagram Protocol (UDP)
UDP socket is implemented through
eq.net.UDPSocket
var socket = UDPSocket.create();

User Datagram Protocol (UDP)
socket.send("This is data to send".to_utf8_buffer(false), "192.168.1.1", 1503);
if(socket.bind(1503) == false) {
Log.error("Failed to bind to UDP port 1503");
}
var buf = DynamicBuffer.create(8192);
if(socket.receive(buf, 1000000) > 0) {
// data was received
}
A call to bind() can be made to choose a
specific port number. If none is bound, then a
port is chosen automatically
To send and receive data, use the send() and
receive() methods

HTTP client
Eqela also provides an implementation of an HTTP
client, which enables Eqela applications to easily
retrieve web data over the HTTP protocol.
The HTTP API can be called either in a background
thread, or in the current thread, depending on the
requirement.
The HTTP API will receive an object of type
eq.net.HTTPRequest, and will return an object of
type eq.net.HTTPResponse.

Uniform Resource Locator (URL)
 URL is the global address of documents and other
resources on the World Wide Web
 A URL may consist of some of the following
components:
 Scheme name, host name, port number, path, query
string and fragment identifier
The syntax is:
scheme://host:port/path?query_string#fragment_id

Uniform Resource Locator (URL)
Uniform Resource Locator is implemented through
eq.net.URL
var url = URL.for_string(str);

Constructing an HTTPRequest
var query = HTTPRequest.create()
.set_method("GET")
.set_url(URL.for_string("http://www.eqela.com")));
var query = HTTPRequest.GET("http://www.eqela.com");
The HTTPRequest class is very flexible, and all
aspects of the query can be configured,
including HTTP headers and cookies.

Using the HTTPClient
Once the query is constructed, it can be executed
through eq.net.HTTPClient
// Execute the query synchronously
var response = HTTPClient.get_response(query);
// Execute the query asynchronously:
HTTPClient.query(query, listener);
// The second parameter supplies a listener object of type
// eq.api.EventReceiver that will be notified of the
// query progress and the final result.

HTTP client listener
The listener could be implemented as follows:
class MyListener : EventReceiver
{
public void on_event(Object o) {
if(o == null) {
// request failed
}
else if(o is HTTPResponse) {
// response was received
}
}
}

Higher level protocols
Eqela offers some convenience implementations of
higher level protocols:
eq.web.rss – RSS news aggregation
eq.web.smtp – Sending email via SMTP

DATA ACCESS (eq.data)

The eq.data API
The eq.data module provides an easy-to-use object
oriented database / data management API
The following are the main classes and interfaces:
Database
Table
IteratorWrapper
SqlDatabase
SqlStatement

Local database access
// open a database, creating it if necessary
var f = File.for_native_path(“C:mydatabase.db”);
var db = SqlDatabase.for_file(f);
if(db == null) {
// db does not exist
db = SqlDatabase.create_file(f);
if(db != null) {
db.execute(db.prepare(
“CREATE TABLE test ( id INTEGER, text TEXT );”));
}
}
→ Different backend implementations per each platform. Currently all
implementations are based on Sqlite
→ Currently not available for HTML5 builds

Databases: Convenience API
var db = new Database();
db.add_table(Table.for_name(“users”).set_index(“username”));
db.add_table(Table.for_name(“sessions”));
if(db.open(File.for_native_path(“C:mydatabase.db”)) == false)
{
// FAILED
}
foreach(PropertyObject record in db.query_all(“users”)) {
// process the record
}
→ Utilizes the SqlDatabase API for actual functionality
→ Automatically creates tables, generates queries and other SQL statements

SqlDatabase: Other databases
A database driver for any SQL database can be
integrated by creating a new class that implements
SqlDatabase
Third party native drivers can be integrated by
embedding calls to the third party driver API
(Oracle, MS SQL, MySQL, ..)

Connecting to databases from mobile devices: What
kind of considerations does this involve?

Direct connectivity
“Direct connectivity” : A mobile device connects
straight to the database server, and executes SQL
instructions on it
+ A very straightforward concept
- Security concerns
- Possible connectivity issues
- Lack of database drivers for mobile devices

Connectivity via gateway
An intermediate server / service that handles the
mobile device's requests, and communicates directly
with the database. Best implemented using HTTP
+ No need to expose database server to the Internet
+ HTTP connectivity is universal
+ No need for database drivers (HTTPClient will do)
- Must set up a gateway service

Thank you

Networking and Data Access with Eqela

More Related Content

What's hot (19)

Viewers also liked (19)

Similar to Networking and Data Access with Eqela (20)

Recently uploaded (20)

Networking and Data Access with Eqela