Wifi Direct Based Chat And File Transfer Android Application

2
1.1 What is Android ?
Android is basically an operating system for smartphones. But we find now integrated into
PDAs, Touch pads or televisions, even cars (trip computer) or netbooks. The OS was
created by the start-up of the same name, which is owned by Google since 2005.
1.1.1 Specifications
This operating system is based on version 2.6 of Linux, so it has a monolithic system
kernel, what means that all system functions and drivers are grouped into one block of
code.
1.1.2 Architecture
Android consists of five layers:
-The Linux kernel 2.6-which includes useful drivers that allow for example Wi-Fi or
Bluetooth.
-The library written in C and C + + that provide higher level functionality such as an
HTML engine, or a database (SQLite).
-A runtime environment for applications based on a virtual machine, made for inefficient
machines such as telephones. The aim is to translate JAVA in machine language
understood by Android.
-A JAVA framework that allows applications running on the virtual machine to organize
and cooperate.
-The user applications written in Java (Web browser, contact manager etc.).
1.2 Understanding the Android Software Stack
The Android software stack is composed of the elements shown in Figure 1-1 and
described in further detail below it. Put simply, a Linux kernel and a collection of C/C++
libraries are exposed through an application framework that provides services for, and
management of, the run time and applications.

3
Figure 1.1- Android Software Stack
1.2.1 Linux Kernel
Core services (including hardware drivers, process and memory management, security,
network, and power management) are handled by a Linux 2.6 kernel. The kernel also
provides an abstraction layer between the hardware and the remainder of the stack.
1.2.2 Libraries
Running on top of the kernel, Android includes various C/C++ core libraries such as libc
and SSL, as well as:
A media library for playback of audio and video media A
Surface manager to provide display management
Graphics libraries that include SGL and OpenGL for 2D and 3D graphics SQLite for
native database support
SSL and WebKit for integrated web browser and Internet security
1.2.3 Android Run Time
What makes an Android phone an Android phone rather than a mobile Linux
implementation is the Android run time. Including the core libraries and the Dalvik virtual
machine, the Android run time is the engine that powers your applications and, along with
the libraries, forms the basis for the application framework.

4
1.2.4 Core Libraries
While Android development is done in Java, Dalvik is not a Java VM. The core Android
libraries provide most of the functionality available in the core Java libraries as well as the
Android-specific libraries.
1.2.5 Dalvik Virtual Machine
Dalvik is a register-based virtual machine that‘s been optimized to ensure that a device can
run multiple instances efficiently. It relies on the Linux kernel for threading and low-level
memory management.
1.2.6 Application Framework
The application framework provides the classes used to create Android applications. It also
provides a generic abstraction for hardware access and manages the user interface and
application resources.
1.2.7 Application Layer
All applications, both native and third party, are built on the application layer using
the same API libraries. The application layer runs within the Android run time using
the classes and services made available from the application framework
1.3 The Dalvik Virtual Machine
One of the key elements of Android is the Dalvik virtual machine. Rather than use a
traditional Java virtual machine (VM) such as Java ME (Java Mobile Edition), Android
uses its own custom VM designed to ensure that multiple instances run efficiently on a
single device.
The Dalvik VM uses the device‘s underlying Linux kernel to handle low-level
functionality including security, threading, and process and memory management. It‘s also
possible to write C/C++ applications that run directly on the underlying Linux OS. While
you can do this, in most cases there‘s no reason you should need to.
All Android hardware and system service access is managed using Dalvik as a middle tier.
By using a VM to host application execution, developers have an abstraction layer that
ensures they never have to worry about a particular hardware implementation.
The Dalvik VM executes Dalvik executable files, a format optimized to ensure minimal
memory footprint.
The .dex executable is created by transforming Java language compiled classes using the
tools supplied within the SDK.

5
1.4 Android Application Architecture
Android‘s architecture encourages the concept of component reuse, allowing you to
publish and share activities, services, and data with other applications with access
managed by the security restrictions you put in place.
The same mechanism that lets you produce a replacement contact manager or phone
dialer can let you expose your application components to let other developers create
new UI front ends and functionality extensions, or otherwise build on them.
The following application services are the architectural cornerstones of all Android
applications, providing the framework you‘ll be using for your own software:
 Activity Manager Controls the life cycle of your activities, including
management of the activity Stack. 
 Views Are used to construct the user interfaces for your activities. 
 Notification Manager Provides a consistent and non-intrusive mechanism for
signalling your Users.
 Content Providers Lets your applications share data between applications. 
 Resource Manager Supports non-code resources like strings and graphics to be
externalized.
1.5 Android Libraries
Android offers a number of APIs for developing your applications. The following list of
core APIs should provide an insight into what‘s available; all Android devices will offer
support for at least these APIs:
 android.util The core utility package contains low-level classes like specialized
containers, string formatters, and XML parsing utilities. 

 android.os The operating system package provides access to basic 
operating System services like message passing, interprocess
communication, clock functions
 android.graphics The graphics API supplies the low-level graphics classes that
support canvases,colors, and drawing primitives, and lets you draw on canvases. 

 android.text The text processing tools for displaying and parsing text. 


 android.database Supplies the low-level classes required for handling cursors
when working with databases. 

6
 android.content The content API is used to manage data access and publishing by
providing services for dealing with resources, content providers, and packages. 



 android.view Views are the core user interface class. All user interface elements are
constructed using a series of Views to provide the user interaction components. 


 android.widget Built on the View package, the widget classes are the ―here‘s one
we created earlier‖ user-interface elements for you to use in your applications. They
include lists, buttons, and layouts. 


 com.google.android.maps A high-level API that provides access to native map
controls that you can use within your application. Includes the MapView control as
well as the Overlay and MapController classes used to annotate and control your
embedded maps. 

 android.app A high-level package that provides access to the application model. The
application package includes the Activity and Service APIs that form the basis for all
your Android applications. 


 android.provider To ease developer access to certain standard Content Providers
(such as the contacts database), the Provider package offers classes to 
provide access to standard databases included in all Android distributions.
 android.telephony The telephony APIs give you the ability to directly interact with the
device‘s phone stack, letting you make, receive, and monitor phone calls, phone status,
and SMS messages.
 android.webkit The WebKit package features APIs for working with Web- based 
content, including a WebView control for embedding browsers in your activities and a cookie
manager.
 In addition to the Android APIs, the Android stack includes a set of C/C++ libraries
that are exposed through the application framework. These libraries include: 



1.6 Advanced Android Libraries
The core libraries provide all the functionality you need to start creating applications for
Android, but it won‘t be long before you‘re ready to delve into the advanced APIs that
offer the really exciting functionality.
Android hopes to target a wide range of mobile hardware, so be aware that the suitability
and implementation of the following APIs will vary depending on the device upon which
they are implemented.


7


 android.location The location-based services API gives your applications 
access to the devices current physical location.
Location-based services provide generic access to location information using
whatever position-fixing hardware or technology is available on the device.
 android.media The media APIs provide support for playback and recording of
audio and video media fi les, including streamed media. 


 android.opengl Android offers a powerful 3D rendering engine using the
OpenGL ES API that you can use to create dynamic 3D user interfaces for your
applications. 


 android.hardware Where available, the hardware API exposes sensor hardware
including the camera, accelerometer, and compass sensors 

 android.bluetooth android.net.wifi , and android.telephony Android also 
provides low-level access to the hardware platform, including Bluetooth, Wi-Fi,
and telephony hardware
1.7 Android and Java
In Java, you write your Java source file, compile it into a Java byte code using the Java
compiler, and then run this byte code on the Java VM. In Android, things are different.
You still write the Java source file, and you still compile it to Java byte code using the
same Java compiler. But at that point, you recompile it once again using the Dalvik
compiler to Dalvik byte code. It is this Dalvik byte code that is then executed on the
Dalvik VM. Figure illustrates this comparison between standard Java (on the left) in
Android using Dalvik (on the right).
Figure 1.2 Java Versus Dalvik

8
You may wonder, why not compile straight from Java into the Dalvik byte code?
There are a couple of good reasons for the extra steps. Back in 2005, when work on
Dalvik started, the Java language was going through frequent changes, but the Java byte
code was more or less set in stone. So, the Android team chose to base Dalvik on Java
byte code instead of Java source code.
A side effect of this is that in theory you could write Android applications in any other
language that compiles down to Java byte code. For example, you could use Python or
Ruby. I say ―in theory‖ because in practice the appropriate libraries that are part of the
SDK would need to be available. But it is likely that the open source community will come
up with a solution to that in the future.
Another thing to keep in mind is that Android Java is a nonstandard collection of Java
classes. Java typically ships in:
-Java Standard Edition
Used for development on basic desktop-type applications
-Java Enterprise Edition (aka J2EE or JavaEE) Used for
development of enterprise applications
-Java Micro Edition (aka J2ME or JavaME)
-Java for mobile applications
Android‘s Java set of libraries is closest to Java Standard Edition.
The major difference is that Java user interface libraries (AWT and Swing) have been
taken out and replaced with Android-specific user interface libraries. Android also adds
quite a few new features to standard Java while supporting most of Java‘s standard
features. So, you have most of your favourite Java libraries at your disposal, plus
manynew ones.
1.8 Application Framework
The application framework is a rich environment that provides numerous services to help
you, the app developer, get your job done. This is the best-documented and most
extensively covered part of the platform because it is this layer that empowers developers
to get creative and bring fantastic applications to the market.
In the application framework layer, you will find numerous Java libraries specifically built
for Android. You will also find many services (or managers) that provide the eco-system
of capabilities your application can tap into, such as location, sensors, WiFi,telephony, and
so on.

9
1.9 Android Version
Android 5.0 - Lollipop
Fig 1.3 -Lollipop
Android 5.0 "Lollipop" was unveiled under the codename "Android L" on June 25, 2014,
during Google I/O. It became available as official over-the-air (OTA) updates on November
12, 2014, for select devices that run distributions of Android serviced by Google, including
Nexus and Google Play edition devices. Its source code was made available on November 3,
2014.Lollipop features a redesigned user interface built around a responsive design language
referred to as "material design". Other changes include improvements to the notifications,
which can be accessed from the lockscreen and displayed within applications as top-of-the-
screen banners. Furthermore, Google made internal changes to the platform, with the Android
Runtime (ART) officially replacing Dalvik for improved application performance, and with
changes intended to improve and optimize battery usage, known internally as Project Volta
Android 4.4 - KitKat
Figure 1.4 – KitKat
Google announced Android 4.4 KitKat on September 3, 2013. Although initially under the
"Key Lime Pie" ("KLP") codename, the name was changed because "very few people
actually know the taste of a key lime pie."[129] Some technology bloggers also expected the
"Key Lime Pie" release to be Android 5.[130] KitKat debuted on Google's Nexus 5 on
October 31, 2013, and was optimised to run on a greater range of devices than earlier
Android versions, having 512 MB of RAM as a recommended minimum; those
improvements were known as "Project Svelte" internally at Google.[131] The required
minimum amount of RAM available to Android is 340 MB, and all devices with less than
512 MB of RAM must report themselves as "low RAM" devices.

10
Android 4.1-4.3 - Jelly Bean
Figure 1.5 – Jelly Bean
Jelly Bean arrived at Google IO 2012, with the release of the ASUS Nexus 7, followed by a
quick update for unlocked Galaxy Nexus phones. Later in the year, the release of the Nexus
10 and Nexus 4 updated things from 4.1 to 4.2 and on to 4.3, but the version remained Jelly
Bean. The release polished the UI design started in Ice Cream Sandwich, and brought
several great new features to the table.
Besides the new focus on responsiveness with Project Butter, Jelly Bean brings multi-user
accounts, actionable notifications, lock screen widgets, quick-settings in the notification bar,
Photosphere to the "stock" Android camera and Google Now.
Jelly Bean is hailed by many as the turning point for Android, where all the great services
and customization options finally meet great design guidelines. It's certainly very visually
pleasing, and we'd argue that it's become one of the nicest looking mobile operating systems
available.
Android 4.0 - Ice Cream Sandwich
Figure 1.6 – Ice Cream Sandwich
The follow-up to Honeycomb was announced at Google IO in May 2011 and released in
December 2011. Dubbed Ice Cream Sandwich and finally designated Android 4.0, Ice

11
Cream Sandwich brings many of the design elements of Honeycomb to smartphones, while
refining the Honeycomb experience.
The first device to launch with ICS was the Samsung Galaxy Nexus.
1.10Wifi-Direct
1.10.1 Introduction
• Wi-Fi direct is new technology defined by the Wi-Fi alliance aimed at enhancing
direct device to device communication without requiring a wireless access point.
• Wi-Fi direct builds upon the successful IEEE 802.11 infrastructure mode and lets
devices negotiate who will take over the AP-like functionalities.
• Direct device to device connectivity was already possible in original IEEE 802.11
standard but it contains many drawbacks such as lack of power saving or extended
QoS capabilities.
• Wi-Fi device to device communication space is 802.11z, also known as Tunneled
Direct Link Setup (TDLS), which enables direct device to device communication but
requires station to associate with the same AP.
1.10.2 Technical Overview
• In a typical Wi-Fi network, client scans and associate to wireless networks available,
which are created and announced by Access Points (AP).
• Wi-Fi Direct is that these roles are specified as dynamic, and hence a Wi-Fi Direct
device has to implement both the role of a client and the role of an AP.
• These roles are therefore logical roles that could even be executed simultaneously by
the same device, this type of operation is called Concurrent mode.
•
1.10.3 Architecture
• Wi-Fi direct device communicate by establishing P2P group.
• The device implementing AP-like functionality in P2P group is referred to as the P2P
Group Owner (P2P GO), and device acting as client are known as P2P clients.
• Once P2P group is established, other P2P clients can join the group as in a traditional
Wi-Fi network.
• When the device act as both as P2P client and as P2P GO the device will typically
alternate between the two roles by time-sharing the Wi-Fi interface.(Example: Laptop
2 in upper fig.)
• Like a traditional AP, a P2P GO announces itself through beacons, and has to support
power saving for its associated clients.
• Only the P2P GO is allowed to cross-connect the devices in its P2P group to an
external network (Example: Mobile in upper fig.)

12
• This connection must be done at network layer, typically implemented using Network
Address Translation (NAT).
• Wi-Fi direct does not allow transferring the role of P2P GO within the group.
Figure 1.7 – Wifi Direct Architecture
1.10.4 Group Formation
• Three types of group formation techniques are Standard, Autonomous and Persistent
cases.
• Group Formation procedure involves two phases-
 Determination of P2P Group owner
 Negotiated - Two P2P devices negotiate for P2P group owner based
on desire/capabilities to be a P2P GO
 Selected - P2P group Owner role established at formation or at an
application level
 Provisioning of P2P Group
 Establishment of P2P group session using appropriate credentials
 Using Wi-Fi simple configuration to exchange credentials.
• Standard: In this case the P2P device have to discover each other, and then negotiate
which device will act as P2P GO.
• Its start by performing a traditional Wi-Fi scan, by means of which they can discover
existent groups and Wi-Fi network.

13
• To prevent conflicts when two devices declare the same GO Intent, a tie-breaker bit is
included in the GO Negotiation Request, which is randomly set every time a GO
Negotiation Request is sent.
Figure 1.8 – Group Formation in Wifi Direct
• Autonomous: A P2P device may autonomously create a P2P group, where it
immediately becomes the P2P GO, by sitting on a channel and starting a beacon.
• Other devices can discover the established group using traditional scanning
mechanisms.
• As compared to previous case, the discovery phase is simplified in this case as the
device establishing the group does not alternate between states, and indeed no GO
negotiation phase is required.
• Persistent: In this process, P2P device can declare a group as persistent, by using
flag in the P2P capabilities attribute present in beacon frames.
• After the discovery phase, if a P2P device recognizes to have formed a persistent
group with the corresponding peer in the past, any of the two P2P devices can use the
Invitation Procedure to quickly re-instantiate the group.
1.10.5 Security
• Wi-Fi Direct devices are required to implement Wi-Fi Protected Setup (WPS) to
support a secure connection with minimal user intervention.
• WPS allows establishing a secure connection by introducing a PIN in the P2P Client,
or pushing a button in the two P2P Devices.
• Following WPS terminology, the P2P GO is required to implement an internal
Registrar, and the P2P Client is required to implement an Enrollee.
• The operation of WPS is composed of two parts. In the first part, the internal
Registrar is in charge of generating and issuing the network credentials, i.e., security
keys, to the Enrollee.

14
• In the second part, the Enrollee (P2P Client) disassociates and reconnects using its
new authentication credentials.
1.10.6 Power Saving
• Wi-Fi Direct defines two new power saving mechanisms: the Opportunistic Power
Save protocol and the Notice of Absence (NOA) protocol.
• Opportunistic Power Save protocol (OPS) allows a P2P GO to save power when all
its associated clients are sleeping.
• The P2P Group Owner can only save power when all its clients are sleeping.
Figure 1.9 – Power Saving in Wifi Direct
• Notice of absence protocol (NOA) allows a P2P GO to announce time intervals,
referred to as absence periods, where P2P Clients are not allowed to access the
channel.
• P2P GO defines a NOA schedule using four parameters:
 Duration that specifies the length of each absence period
 Interval that specifies the time between consecutive absence periods
 Time that specifies the start time of the first absence period after the
current Beacon frame
 Count that specifies how many absence periods will be scheduled
during the current NOA schedule.

15
Fig 1.10- NOA protocol in Wifi Direct
1.10.7 Benefits
 Some of the benefits consumers will see from Wi-Fi Direct devices.
 Mobility & Portability: Wi-Fi Direct-certified devices connect anytime, anywhere.
 Immediate Utility: Users have the ability to create direct connections with the very
first Wi-Fi Direct-certified device they bring home. For example, a new laptop
certified for Wi-Fi Direct can create direct connections with the existing legacy Wi-Fi
devices in the user’s home.
 Ease of Use: Wi-Fi Direct devices have features that allow users to identify available
devices and services before establishing a connection.
 Simple Secure Connections: Wi-Fi Protected Setup makes it simple to create security-
protected connections between devices. Users in most cases will be able to connect at
the push of a button.
1.10.8 Conclusions
• Wi-Fi alliance has recently developed the Wi-Fi Direct technology that builds upon
the Wi-Fi infrastructure mode to enable direct device to device connectivity.
• In this article we presented a thorough overview of the novel technical features
specified in Wi-Fi Direct, following by the group formation, and other performance
analysis such as power saving and security in this device.
• The NOA protocol could also be re-used to virtualize the roles of P2P GO/Client over
multiple concurrent P2P Groups.
• Concurrent operation together with dynamic nature of the P2P GO/Client roles could
be used to improve performance in dense environments, for instance by means of
dynamic relays.

18
The true appeal of Android as a development environment lays in the APIs it provides.
As an application-neutral platform, Android gives you the opportunity to create applications
that are as much a part of the phone as anything provided out of the box. The following list
highlights some of the most noteworthy Android features:
 No licensing, distribution, or development fees or release approval processes.
 Wi-Fi hardware access. 


 GSM, EDGE, and 3G networks for telephony or data transfer, enabling you to
make or receive calls or SMS messages, or to send and retrieve data across mobile
networks. 

 Comprehensive APIs for location-based services such as GPS. 


 Full Multimedia hardware control, including playback and recording with the
camera and microphone. 

 APIs for using sensor hardware, including accelerometers and the compass. 

 Libraries for using Bluetooth for peer-to-peer data transfer. 

 IPC message passing. 

 Shared data stores. 

 Background applications and processes. 

 Home-screen Widgets, Live Folders, and Live Wallpaper. 

 The ability to integrate application search results into the system search. 

 An integrated open-source HTML5 Web Kit-based browser. 


 Full support for applications that integrate map controls as part of their user
interface. 


 Mobile-optimized hardware-accelerated graphics, including a path-based
2Dgraphics library and support for 3D graphics using OpenGL ES 2.0 

20
Chapter 3
Activity Life Cycle

21
As a user navigates through, out of, and back to your app, the Activity instances in your app
transition between different states in their lifecycle. For instance, when your activity starts
for the first time, it comes to the foreground of the system and receives user focus. During
this process, the Android system calls a series of lifecycle methods on the activity in which
you set up the user interface and other components. If the user performs an action that starts
another activity or switches to another app, the system calls another set of lifecycle methods
on your activity as it moves into the background (where the activity is no longer visible, but
the instance and its state remains intact).
Within the lifecycle callback methods, you can declare how your activity behaves when the
user leaves and re-enters the activity. For example, if you're building a streaming video
player, you might pause the video and terminate the network connection when the user
switches to another app. When the user returns, you can reconnect to the network and allow
the user to resume the video from the same spot.
This class explains important lifecycle callback methods that each Activity instance
receives and how you can use them so your activity does what the user expects and does
not consume system resources when your activity doesn't need them.
3.1 Starting an Activity:
Unlike other programming paradigms in which apps are launched with a main() method, the
Android system initiates code in an Activity instance by invoking specific callback methods
that correspond to specific stages of its lifecycle. There is a sequence of callback methods
that start up an activity and a sequence of callback methods that tear down an activity.
This lesson provides an overview of the most important lifecycle methods and shows you
how to handle the first lifecycle callback that creates a new instance of your activity.
3.2 Understand the Lifecycle
During the life of an activity, the system calls a core set of lifecycle methods in a sequence
similar to a step pyramid. That is, each stage of the activity lifecycle is a separate step on
the pyramid. As the system creates a new activity instance, each callback method moves
the activity state one step toward the top. The top of the pyramid is the point at which the
activity is running in the foreground and the user can interact with it.
As the user begins to leave the activity, the system calls other methods that move the
activity state back down the pyramid in order to dismantle the activity. In some cases, the
activity will move only part way down the pyramid and wait (such as when the user
switches to another app), from which point the activity can move back to the top (if the user
returns to the activity) and resume where the user left off.
Depending on the complexity of your activity, you probably don't need to implement all the
lifecycle methods. However, it's important that you understand each one and implement
those that ensure your app behaves the way users expect. Implementing your activity
lifecycle methods properly ensures your app behaves well in several ways, including that it:

22
Does not crash if the user receives a phone call or switches to another app while using your
app.
Does not consume valuable system resources when the user is not actively using it.
Figure 3.1-Android Lifecycle
3.3 Pausing and Resuming an Activity:
During normal app use, the foreground activity is sometimes obstructed by other visual
components that cause the activity to pause. For example, when a semi- transparent activity
opens (such as one in the style of a dialog), the previous activity pauses. As long as the
activity is still partially visible but currently not the activity in focus, it remains paused.
However, once the activity is fully-obstructed and not visible, it stops (which is discussed in
the next lesson).
As your activity enters the paused state, the system calls the onPause() method on your
Activity, which allows you to stop ongoing actions that should not continue while paused
(such as a video) or persist any information that should be permanently saved in case the
user continues to leave your app. If the user returns to your activity from the paused state,
the system resumes it and calls the on Resume() method
3.4 Stopping and Restarting an Activity:
Properly stopping and restarting your activity is an important process in the activity lifecycle
that ensures your users perceive that your app is always alive and doesn't lose their progress.
There are a few of key scenarios in which your activity is stopped and restarted:
The user opens the Recent Apps window and switches from your app to another app. The
activity in your app that's currently in the foreground is stopped. If the user returnsto your
app from the Home screen launcher icon or the Recent Apps window, the activity restarts.
The user performs an action in your app that starts a new activity. The current activity

23
is stopped when the second activity is created. If the user then presses the Back button, the
first activity is restarted.
The user receives a phone call while using your app on his or her phone.
The Activity class provides two lifecycle methods, onStop() and onRestart(), which allow
you to specifically handle how your activity handles being stopped and restarted. Unlike the
paused state, which identifies a partial UI obstruction, the stopped state guarantees that the
UI is no longer visible and the user's focus is in a separate activity (or an entirely separate
app).
3.5 Recreating an Activity:
There are a few scenarios in which your activity is destroyed due to normal app behavior,
such as when the user presses the Back button or your activity signals its own destruction by
calling finish(). The system may also destroy your activity if it's currently stopped and hasn't
been used in a long time or the foreground activity requires more resources so the system
must shut down background processes to recover memory.
When your activity is destroyed because the user presses Back or the activity finishes itself,
the system's concept of that Activity instance is gone forever because the behavior indicates
the activity is no longer needed. However, if the system destroys the activity due to system
constraints (rather than normal app behavior), then although the actual Activity instance is
gone, the system remembers that it existed such that if the user navigates back to it, the
system creates a new instance of the activity using a set of saved data that describes the state
of the activity when it was destroyed. The saved data that the system uses to restore the
previous state is called the "instance state" and is a collection of key- value pairs stored in a
Bundle object.
Caution: Your activity will be destroyed and recreated each time the user rotates the screen.
When the screen changes orientation, the system destroys and recreates the foreground
activity because the screen configuration has changed and your activity might need to load
alternative resources (such as the layout).
By default, the system uses the Bundle instance state to save information about each View
object in your activity layout (such as the text value entered into an EditText object..
Figure 3.2- Recreating an activity

25
Chapter 4
Networking in Android

26
4.1 Overview of HTTP access on Android
4.1.1 Available official API's
Android contains the standard Java network java.net package which can be used to access
network resources. The base class for HTTP network access in the java.net package is
the HttpUrlConnection class.
4.1.2 Required permissions
To access the Internet your application requires the android.permission.INTERNET
permission. To check the network state your application requires the
android.permission.ACCESS_NETWORK_STATE permission.
4.1.3. Good practices for network access under Android
Within an Android application you should avoid performing long running operations on
the user interface thread. This includes file and network access.
As of Android 3.0 (Honeycomb) the system is configured to crash with a
NetworkOnMainThreadException exception, if network is accessed in the user interface
thread.
A typical setup for performing network access in a productive Android application is
using a service. While it is possible to do network access from an activity or a fragment,
using a service typical leads to a better overall design because you code in the activity
becomes simpler.
4.2 Java and HTTP access
Java provides a general-purpose, lightweight HTTP client API to access resources via the
HTTP or HTTPS protocol. The main classes to access the Internet are the java.net.URL class
and the java.net.HttpURLConnection class. The URL class can be used to define a pointer to
a web resource while the HttpURLConnection class can be used to access a web resource.
HttpURLConnection allows you to create an InputStream. Once you have accessed an
InputStream you can read it similarly to an InputStream from a local file. In the latest version
HttpURLConnection supports the transparent response compression (via the headerAccept-
Encoding: gzip, Server Name Indication (extension of SSL and TLS) and a response cache.
4.3 Web Sockets
Web Sockets are a standard based on HTTP for asynchronous message-based communication
between a client and a server. To start a web socket communication, you create a HTTP GET
request with a special HTTP headers. If the server accepts this request, the client and the
server can send each other messages. Messages can be text or binary data and should be
relatively small, as the web socket protocol is intended to be used with small payloads in the
data. It is good practice to use JSON as data format for the messages.

27
4.4 AsyncTask
4.4.1Class-Overview
AsyncTask enables proper and easy use of the UI thread. This class allows to perform
background operations and publish results on the UI thread without having to manipulate
threads and/or handlers. AsyncTask is designed to be a helper class around Thread and
Handler and does not constitute a generic threading framework. AsyncTasks should ideally
be used for short operations (a few seconds at the most.)
An asynchronous task is defined by a computation that runs on a background thread and
whose result is published on the UI thread. An asynchronous task is defined by 3 generic
types, called Params, Progress and Result, and 4 steps, called onPreExecute,
doInBackground, onProgressUpdate and onPostExecute.
4.4.2Usage
AsyncTask must be subclassed to be used. The subclass will override at least one method
(doInBackground(Params...)), and most often will override a second one
(onPostExecute(Result).)
4.4.3 The 4 steps
When an asynchronous task is executed, the task goes through 4 steps:
 onPreExecute(), invoked on the UI thread before the task is executed. This step is
normally used to setup the task, for instance by showing a progress bar in the user
interface.
 doInBackground(Params...), invoked on the background thread immediately after
onPreExecute() finishes executing. This step is used to perform background
computation that can take a long time. The parameters of the asynchronous task are
passed to this step. The result of the computation must be returned by this step and
will be passed back to the last step. This step can also use publishProgress(Progress...)
to publish one or more units of progress. These values are published on the UI thread,
in the onProgressUpdate(Progress...) step.
 onProgressUpdate(Progress...), invoked on the UI thread after a call to
publishProgress(Progress...). The timing of the execution is undefined. This method is
used to display any form of progress in the user interface while the background
computation is still executing. For instance, it can be used to animate a progress bar or
show logs in a text field.
 onPostExecute(Result), invoked on the UI thread after the background computation
finishes. The result of the background computation is passed to this step as a
parameter.
4.4.4 Cancelling a task
A task can be cancelled at any time by invoking cancel(boolean). Invoking this method will
cause subsequent calls to isCancelled() to return true. After invoking this method,
onCancelled(Object), instead of onPostExecute(Object) will be invoked after
doInBackground(Object[]) returns. To ensure that a task is cancelled as quickly as possible,

28
you should always check the return value of isCancelled() periodically from
doInBackground(Object[]), if possible (inside a loop for instance.)
4.4.5 Threading rules
There are a few threading rules that must be followed for this class to work properly:
 The AsyncTask class must be loaded on the UI thread. This is done automatically as
of Jelly Bean.
 The task instance must be created on the UI thread.
 execute(Params...) must be invoked on the UI thread.
 Do not call onPreExecute(), onPostExecute(Result), doInBackground(Params...),
onProgressUpdate(Progress...) manually.
 The task can be executed only once (an exception will be thrown if a second
execution is attempted.)
4.4.6 Memory observability
AsyncTask guarantees that all callback calls are synchronized in such a way that the
following operations are safe without explicit synchronizations.
 Set member fields in the constructor or onPreExecute(), and refer to them in
doInBackground(Params...).
 Set member fields in doInBackground(Params...), and refer to them in
onProgressUpdate(Progress...) and onPostExecute(Result).
4.4.7 Order of execution
When first introduced, AsyncTasks were executed serially on a single background thread.
Starting with DONUT, this was changed to a pool of threads allowing multiple tasks to
operate in parallel. Starting with HONEYCOMB, tasks are executed on a single thread to
avoid common application errors caused by parallel execution. If you truly want parallel
execution, you can invoke executeOnExecutor(java.util.concurrent.Executor, Object[]) with
THREAD_POOL_EXECUTOR.

30
Chapter 5
Other technologies used

31
5.1 Environment
5.1.1 Eclipse IDE
Eclipse is an integrated development environment (IDE). It contains a base workspace and
an extensible plug-in system for customizing the environment. Written mostly in Java,
Eclipse can be used to develop applications. By means of various plug-ins, Eclipse may also
be used to develop applications in other programming languages PHP, Python, R, Ruby
(including Ruby on Rails framework), Scala, Clojure, Groovy, Scheme, and Erlang. It can
also be used to develop packages for the software Mathematica. Development environments
include the Eclipse Java development tools (JDT) for Java and Scala, Eclipse CDT for C/C++
and Eclipse PDT for PHP, among others.
The initial codebase originated from IBM VisualAge.
[2]
The Eclipse software
development kit (SDK), which includes the Java development tools, is meant for Java
developers. Users can extend its abilities by installing plug-ins written for the Eclipse
Platform, such as development toolkits for other programming languages, and can write and
contribute their own plug-in modules.
Version Name Date
Platform
Projects
version
Callisto 30 June 2006 3.2 Callisto projects
Europa 29 June 2007 3.3 Europa projects
Ganymede 25 June 2008 3.4
Ganymede
projects
Galileo 24 June 2009 3.5 Galileo projects
Helios 23 June 2010 3.6 Helios projects
Indigo 22 June 2011 3.7 Indigo projects
Juno 27 June 2012 3.8 and 4.2 Juno projects
Kepler 26 June 2013 4.3 Kepler projects
Luna
25 June 2014
4.4 Luna projects
(planned)
Mars
24 June 2015
4.5 Mars projects
(planned)
Table 5.1- Eclipse Versions
With the exception of a small run-time kernel, everything in Eclipse is a plug-in. This means
that every plug-in developed integrates with Eclipse in exactly the same way as other plug-
ins; in this respect, all features are "created equal". Eclipse provides plug-ins for a wide
variety of features, some of which are through third parties using both free and commercial
models. Examples of plug-ins include for UML, for Sequence and other UML diagrams, a
plug-in for DB Explorer, and many others.

32
5.2 Languages
5.2.1 Java
Java is a computer programming language that is concurrent, class-based, object-oriented,
and specifically designed to have as few implementation dependencies as possible. It is intended
to let application developers "write once, run anywhere" (WORA), meaning that code that
runs on one platform does not need to be recompiled to run on another.
 Java applications are typically compiled to bytecode (class file) that can run on any
Java virtual machine(JVM) regardless of computer architecture.
 Java is, as of 2014, one of the most popular programming languages in use,
particularly for client-server web applications, with a reported 9 million developers. 

 Java was originally developed by James Gosling at Sun Microsystems (which has
since merged into Oracle Corporation) and released in 1995 as a core component of
Sun Microsystems' Java platform. 

 The language derives much of its syntax from C and C++, but it has fewer low-
level facilities than either of them. 
Major release versions of Java, along with their release dates:
 JDK 1.0 (January 21, 1996) 

 JDK 1.1 (February 19, 1997) 

 J2SE 1.2 (December 8, 1998) 

 J2SE 1.3 (May 8, 2000) 

 J2SE 1.4 (February 6, 2002) 

 J2SE 5.0 (September 30, 2004) 

 Java SE 6 (December 11, 2006) 

 Java SE 7 (July 28, 2011) 

 Java SE 8 (March 18, 2014) 

5.2.2 Xml
The design goals of XML emphasize simplicity, generality, and usability over the Internet.
[6]
It is a textual data format with strong support via Unicode for the languages of the world.
Although the design of XML focuses on documents, it is widely used for the representation of
arbitrary data structures,
[7]
for example in web services.
Many application programming interfaces (APIs) developers with processing XML data, and
several based languages have been developed to aid software exist to aid in the definition of
XML-



33
Key terminology
The material in this section is based on the XML Specification. This is not an exhaustive list
of all the constructs that appear in XML; it provides an introduction to the key constructs
most often encountered in day-to-day use.
 (Unicode) character
By definition, an XML document is a string of characters. Almost every
legal Unicode character may appear in an XML document.
 Processor and application 
The processor analyzes the markup and passes structured information to an application. The
specification places requirements on what an XML processor must do and not do, but the
application is outside its scope. The processor (as the specification calls it) is often referred to
colloquially as an XML parser.
 Markup and content 
The characters making up an XML document are divided into markup and content, which
may be distinguished by the application of simple syntactic rules. Generally, strings that
constitute markup either begin with the character < and end with a >, or they begin with the
character & and end with a ;. Strings of characters that are not markup are content. However,
in a CDATAsection, the delimiters <![CDATA[ and ]]> are classified as markup, while the
text between them is classified as content. In addition, whitespace before and after the
outermost element is classified as markup.

 Tag 
A markup construct that begins with < and ends with >. Tags come in three flavors:
 start-tags; for example: <section> 
 end-tags; for example: </section> 
 empty-element tags; for example: <line-break /> 


 Element
A logical document component which either begins with a start-tag and ends with a matching
end-tag or consists only of an empty-element tag. The characters between the start- and end-
tags, if any, are the element's content, and may contain markup, including other elements,
which are called child elements. An example of an element is <Greeting>Hello,
world.</Greeting>(see hello world). Another is <line-break />.

36
Two types of classes are being used in the application:
 Built-in Packages- Packages which are available to developers by the sdk and the
environment. 

 User created classes- Classes which are created by developers for certain special
requirements in the working of application. 


6.1 Built in packages
6.1.1 android.content
Contains classes for accessing and publishing data on a device. It includes three main categories of
APIs:
 Content sharing (android.content)
For sharing content between application components.
 Package management (android.content.pm)
For accessing information about an Android package (an .apk), including information about its
activities, permissions, services, signatures, and providers. The most important class for accessing this
information is PackageManager.
 Resource management (android.content.res)
For retrieving resource data associated with an application, such as strings, drawables, media, and
device configuration details. The most important class for accessing this data is Resources.
6.1.2 android.net.wifi.p2p
Provides classes to create peer-to-peer (P2P) connections with Wi-Fi Direct.
Using these APIs, you can discover and connect to other devices when each device supports Wi-Fi
Direct, then communicate over a speedy connection across distances much longer than a Bluetooth
connection. The primary class you need to work with is WifiP2pManager, which you can acquire by
calling getSystemService(WIFI_P2P_SERVICE). The WifiP2pManager includes APIs that allow you
to:
 Initialize your application for P2P connections by calling initialize()
 Discover nearby devices by calling discoverPeers()
 Start a P2P connection by calling connect()
6.1.3 android.os
Provides basic operating system services, message passing, and inter-process communication
on the device.
6.1.4 android.app
Contains high-level classes encapsulating the overall Android application model.
An Android application is defined using one or more of Android's four core application components.
Two such application components are defined in this package: Activity and Service. The other two
components are from the android.content package: BroadcastReceiver and ContentProvider.
6.1.5 android.media
Provides classes that manage various media interfaces in audio and video.
The Media APIs are used to play and, in some cases, record media files. This includes audio (e.g.,
play MP3s or other music files, ringtones, game sound effects, or DTMF tones) and video (e.g., play a
video streamed over the web or from local storage).

37
6.1.6 java.net
Provides the classes for implementing networking applications.
The java.net package can be roughly divided in two sections:
A Low Level API, which deals with the following abstractions:
Addresses, which are networking identifiers, like IP addresses.
Sockets, which are basic bidirectional data communication mechanisms.
Interfaces, which describe network interfaces.
A High Level API, which deals with the following abstractions:
URIs, which represent Universal Resource Identifiers.
URLs, which represent Universal Resource Locators.
Connections, which represents connections to the resource pointed to by URLs.
6.1.7 java.io
Provides for system input and output through data streams, serialization and the file system. Unless
otherwise noted, passing a null argument to a constructor or method in any class or interface in this
package will cause a NullPointerException to be thrown.
6.1.8 android.preference
Provides classes that manage application preferences and implement the preferences UI. Using these
ensures that all the preferences within each application are maintained in the same manner and the
user experience is consistent with that of the system and other applications.
6.1.9 android.widget
The widget package contains (mostly visual) UI elements to use on your Application screen. You can
also design your own.
To create your own widget, extend View or a subclass. To use your widget in layout XML, there are
two additional files for you to create
6.2 User created classes
6.2.1 Classes And Their Functions
 ChatActivity.java 
o onCreate() – Called when activity is created.
o onClick() – Handles the control of buttons for launching activities like review and
submit attendance.
o onResume() –Called when activity is resumed.
o onBackPressed() – Called when back button is pressed.
o onActivityResult(int, int, Intent) – Called when Intent is received back to an activity for
result.
o sendMessage(int) – Called to send a message of specific type.
o refreshList(Message, boolean) – Called to refresh the chat screen after receiving an

38
Image Message.
o copyTextToClipboard(long ) – Called to copy text to clipboard.
o shareMedia(long , int) – Called to share Media to various applications.
 Drawing Activity.java 
o onItemClick() – Handles the click of the list items of absent students for review.
o onItemChecked() – Triggered when an item is checked.
o paintClicked(View view) – Triggered when drawing is used.
o chooseBrush() – Called to choose Brush size.
o chooseEraser() – Called to choose Eraser size.
 FilePickerActivity.java 
o chooseFile(final Item) – Called to choose a file for sending.
o fillDirectory(File file) – Called to create different file hierarchy.
 MainActivity.java 

o onCreate(Bundle) – Called when activity is created.
o onCreateOptionsMenu(Menu) – Called to create Options Menu
o goToChat() – Called to go to Chat Screen.
o saveChatName(Context, String) – Called to save the chat name of User.
o loadChatName(Context context) – Called to load the chat name of User.
 MessageService.java 
o onStartCommand(Intent intent, int flags, int startId)– This is used when a message
activity is started.
 RecordActivity.java

o startRecording() – This is called when a recording of audio is started.
o stopRecording() – This is called when a recording of audio is stoped.
 ViewImage.java 
o Used to present and open a image which is received from user within the application.
 WebViewActivity.java 
o onReceivedTitle(WebView, String )– Used to open a specific link.
 ReceiveMessageClient.java 
o Void doInBackground(Void... params) – Used to read data from inputstream.

39
 ReceiveMessageServer.java 
o Void doInBackground(Void... params) – Prepares the inputstream for client
to receive data.
 SendMessageClient.java 
o Void doInBackground(Void... params) – Used to send data to outputstream.
 ReceiveMessageClient.java 
o Void doInBackground(Void... params) – Preapares data to be send to
outputstream.
 Image.java

o public Bitmap getBitmapFromUri()-retreive bitmap from its uri
o public Bitmap decodeSampleBitmapFromUrl(int width,int height)- loads
bitmap in size calculated

 MediaFile.java

o public byte[] fileToByteArray()- converts media file to byte array
o public String getRealPathFromURI(Context context,Uri contentUri)- Returns
path of file from uri
 Message.java

o public void saveByteArrayToFile(Context context)- saves the received
message bytes to a path according to the type of message

 WifiDirectBroadcastReceiver.java(Singleton Class)

o public void activateGoToChat(String role)- Starts the chat according to
role(server or client)
o public int isGroupOwner()- returns true if device is group owner

42
7.1 Start-up screen
The start screen is the connection establishment page where a user will be asked to join a Wi-
Fi Direct network if not connected
.
Fig. 7.1 - start-up screen

43
7.2 Connection Establishment Screen
The next screen is the connection establishment screen.
 One device has to request other to accept his request

 Other device has to accept the request for successful connection establishment. 

. 



Fig. 7.2 – connection establishment screen

44
7.3 User Screen
The next screen is the user screen.
 User sets a new name giving his/her details for first time.
 Automatically sets the name if previously set by user.
 User can change the user name on setup phase. 
Fig 7.3 – User screen

45
7.4 Chat Screen
1) Simple Text Messages:
 Sender is depicted in White Bubble
 Receiver is depicted in Blue Bubble.
 Size of Bubble in dynamic in nature which depends on size and length of
message to be sent
Fig 7.4 – Chat screen(Sending Of Text Messages)

46
7.5 Chat Screen
2) Selecting Options In Image Transfer:
 A pop up menu comes on touching image button
 Two Options Are Available:
o Pick Image from Gallery.
o Take Image from Camera.
Fig 7.5 – Chat screen (Picking Options For Image Transfer)

47
7.6 Chat Screen
3) Picking/Sending Image From Galley:
 On Selecting Pick Image, it goes to Gallery. 
 A File is selected and when clicked ,it is send
Fig 7.6 – Chat screen (Picking From Galley And Sending)

48
7.7 Chat Screen
4) Capturing Image From Camera And Sending:
 On Selecting Take Photo, it goes to Camera.
 On clicking Image it gives a preview of image is provided.
o It can be discarded or,
o It can be used to send to other user. 
Fig 7.7 – Chat screen (Capturing From Camera And Sending)

49
7.8 Chat Screen
5) Selecting Send Drawing Option:
 On Selecting send drawing option, it goes to Draw Activity.
 Can be used to:
o Send paintings.
o Send Smilies.
o Send any type of drawings.
  User can express its feelings better when there is no limitation of using static
smilies.


Fig 7.8 – Chat screen (An Interface for Drawing)

50
7.9 Chat Screen
6) Using Different Paint And Eraser Sizes:
 Different Paint Brushes are available.
 Different Eraser sizes are available.
 Total of three sizes of erasers/brushes are available.
 A total of 6 colours are available to be choose from.
Fig 7.9 – Chat screen (An Interface for Drawing)

51
7.10 Chat Screen
7) Making Drawings And Sending:
 Different Paint Brushes and colours can be used to make smilies, drawings etc.
 Click Save and Send button to send it instantaneously.
Fig 7.10 – Chat screen (Drawing smilies and sending)

52
7.11 Chat Screen
8) Recording And Sending Videos
 We can record videos of any length.
 After recording videos can be previewed and send it only if you want.
 Speed of 2-3 Mbps can be achieved.
Fig 7.11 – Chat screen (Drawing smilies and sending)

53
7.12 Chat Screen
9) Recording Voice Messages
 Same icons of different colour are used to depict whether it is recording or not.
 Blue Icon shows that it is recording.
 Red Icon shows that it stops recording.
Fig 7.12 – Chat screen (Recording Audio Messages)

54
7.13 Chat Screen
10)Previewing And Sending Voice Messages
 Audio Message recorded earlier can be previewed and we can listen the voice
again.
 The message can be discarded.
 On clicking tick button , the message can be sent.
Fig 7.13 – Chat screen (Previewing and Sending Audio Message)

55
7.14 Chat Screen
11)Sending Files From Phone Storage/ SD Card
 Any Attachment can be sent from SD/Phone memory.
 Attachment can be:
o PDF file
o Mp3,Mp4 file.
o .config file
o .os file
o Any type of file.
 On clicking file , the message can be sent.
Fig 7.14 – Chat screen (Selecting And Sending Files As Attachment)

56
7.15 Chat Screen
12)Copying/Sharing Text Messages in Chat
 Any Text Message can be copied to clipboard and can be used to copy it to
other applications.
 Text can share with multiple applications like
o Gmail
o Facebook
o Messenger (Facebook)
o Hangouts
Fig 7.15 – Chat screen (Sharing/Copying Text Messages to Other Applications)

57
7.16 Chat Screen
13)Sending And Opening Web Links
 Any type of web links can be send through the chat messages
 It is shown in blue colour with underlined.
 Presence of www is not necessary like google.com
 Web Links are opened in web activity within the application without any
browser
Fig 7.16 – Chat screen (Sending and Opening web links)

58
7.17Chat Screen
14)Calling And Saving Mobile Numbers in Chat
 Any type of mobile number can be send through the chat messages
 It is shown in blue colour with underlined.
 Number can be saved or called using truecaller /default caller etc applications
directly
Fig 7.17 – Chat screen (Calling And Saving Mobile Numbers)

59
7.18 Chat Screen
15)Warning Message On Closing Application
 This application doesn’t used any type of messages.
 Once messages are deleted ,they cannot be retrieved.
 So the user must be aware of such action ,which can be made aware by showing
a pop up warning message.
Fig 7.18 – Chat screen (Warning Message)

60
7.19 Download Folder
 All the media and files which are received by user are stored in the Download
folder (preference is SD Card).
 In case of Samsung mobile phones, it is stored in phone memory.


Fig 7.19 – Downloads Folder

62
Chapter8
Conclusion and Future Scope

63
8.1 Problems with Wi-Fi Direct:
The problems we have observed while developing the application are that
 Wi-Fi Direct is still an emerging technology.
 How many devices can connect?
 A Wi-Fi Direct-certified network can be one-to-one, or one to-many. The
number of devices in a Wi-Fi Direct-certified group network is expected to be
smaller than the number supported by traditional standalone access points
intended for consumer use. Connection to multiple other devices is an
optional feature that will not be supported in all Wi-Fi Direct-certified
devices; some devices will only make 1:1 connections.
 Connection to multiple other devices is an optional feature that will not be
supported in all Wi-Fi Direct-certified devices; some devices will only make
1:1 connections.
 Wi-Fi Direct-certified devices will be identifiable as Wi-Fi Direct-certified
devices to infrastructure access points. APs can prevent devices currently
using Wi-Fi Direct from connecting to the AP, or disconnect them if already
connected, while Wi-Fi Direct is in use and/or configure their parameters
including channel.
 Several Wi-Fi Alliance members that make devices of limited processing
capabilities contributed to the specification development process to ensure
that it is applicable to such devices.
 Bluetooth and Wi-Fi Interference Cases . A Wi-Fi receiver senses a Bluetooth
signal at the same time a Wi-Fi signal is being sent to it. The effect is most
pronounced when the Bluetooth signal is within the 22-MHzwide pass band
of the Wi-Fi receiver.
 A Bluetooth receiver senses a Wi-Fi signal at the same time a Bluetooth
signal is being sent to it; the effect is most pronounced when the Wi-Fi signal
is within the pass band of the Bluetooth receiver
These problems have caused a major hindrance in the development of the application.
8.2 Conclusion
 This document has discussed techniques used, why they were used and the detailed
working of the application.
 The main work is done on the interface which is very simple and is user friendly.
 This application can be used in any school/university as it does not have any

64
restriction. All the possible test cases have been tested for the bug free working
of the application.
 This needs no central server /database and only Wi-Fi enabled devices are required.
 Wi-Fi direct is made for temporarily connecting a few devices in an easy-to-use and
secure way, but it does not work well for larger network topologies.
 The major problem a user confronts when using the Wi-Fi direct is that the device
are not compatible with each other. The device crashes or gets stuck if we try to
exchange multimedia.
 The solution to overcome this problem is to develop the link layer and see that the
connection is still on when the exchange is going on. This Application would work
in a better way if there is device compatibility and Wi-Fi direct is extended to all
the smart devices.
 Finally, if Wi-Fi Direct becomes a widespread technology as expected, it faces the
challenge of improving coexistence.
8.3 Future Scope
There are various scopes for this application in future. Some of them can be as follows:
 This application can be further expanded to connect to multiple clients and be used
to transfer files to multiple clients at once.
 An alternative application can be used to create live streaming of videos within the
range of Wi-Fi.
 An alternative application can be used to create live voice calling feature within the
range of Wi-Fi. .
 Further improvements can be made regarding continuous file transfer speed of Wi-Fi
Direct.
 Different types of smilies like in WhatsApp ,Facebook can be included in it.
 There are several other factors that could give Wi-Fi Direct a much-needed boost in
the near future.
o The number of connected devices as a whole is on the rise, as manufacturers
seek to add IP connectivity to everything from cameras to tablets and TVs.
The Wi-Fi Alliance also threw its lot in with the Digital Living Network
Alliance (DLNA) last November, ensuring that DLNA certified devices now
also support Wi-Fi Direct.
o Wi-Fi Direct devices are still on the way. In-Stat predicts that every
connected device with Wi-Fi will ship with Wi-Fi Direct by 2014. Given that
Wi-Fi Direct devices are also backwards-compatible with other Wi-Fi
products that means a huge number of consumer electronics will be capable
of connecting over local wireless networks without the Internet. Only one
device in each wireless pairing has to be Wi-Fi Direct-enabled.

65
8.4 References
Books
[1]. James Steel and Nelson To, Android Developers Cookbook, Pearson
Education, 2011.
[2]. Donn Felker with Joshua Dobbs, Android Application Development For
Dummies, Wiley Publishing, Inc.
[3]. Lucas Jordan and Pieter Greyling, Practical Android Projects, Apress Publication.
[4]. Marko Gargenta, Learning Android, O’REILLY Publication.
[5]. Reto Meier, Professional Android Application Development, Wiley Publishing Inc.
[6]. Frank Ableson, Charlie Collins and Robi Sen, Unlocking Android, Manning
Publication Co.
World Wide Web
[7]. Android Developers, http://developer.android.com/develop/index.html, 4th
October,
2013.
[8]. How to switch between intents, http://www.androidhive.info/2011/08/ 23rd
November, 2013.
[9]. Android related questions, http://www.stackoverflow.com
[10]. Eclipse, Android and Java training and support,
http://www.vogella.com/.
[11]. Beginning Java forum, http://www.coderanch.com/
[12]. http://www.wi-fi.org/files/faq_20101021_Wi-Fi_Direct_FAQ.pdf
[13]. http://anrg.usc.edu/ee579_2012/Group09/#wifidirect
[14] http://developer.android.com/guide/topics/connectivity/wifip2p.html

Wifi Direct Based Chat And File Transfer Android Application

More Related Content

What's hot

Similar to Wifi Direct Based Chat And File Transfer Android Application

Recently uploaded

Wifi Direct Based Chat And File Transfer Android Application