UIDAI based voting application on ANDROID

1. INTRODUCTION

The main objective of the proposed solution is to automate the voting process and

activities related to voting process through Internet and mobile (android). This

solution will facilitate the voters and nominees with the different modules. This

solution is very much necessary for the elections in the local bodies as well as general

body. Based on the user information we will send a secured number to mobile

(android), using this secured number user will vote for his preferred politician city

wise.

1.1 MOTIVATION

Our country is the biggest democratic nation in the world where elections play a

very crucial role in electing the public representatives. But in the existing system

there are lots of malpractices which take place and there is no proper mechanism to

stop duplication of votes, rigging and even there are chances of vulnerable voting

machines to malfunction. So, considering these things, there is a scope for an

alternative which provides immense security and avoid any duplication of poles,

rigging and even providing results as early as possible.

1.2 PROBLEM DEFINITION

The problem lies in the existing system where the entire system is a manual

process. This is not secured and there are chances of rigging in the present system of

Electronic voting and even ballot box paper voting. The vulnerable voting machines

can be compromised by taking control over them using various techniques by the

experts or specialists who can modify the voting machines and manipulate the results.

This is the defect of the existing system. To overcome this, there is a need to provide

1

an alternative and a secured way by which the elections can be held without any

duplication of votes and rigging.

1.3 OBJECTIVE OF THE PROJECT

The main objective of this project is to provide an effectual mechanism by

providing a key using which only authenticated user can vote for his constituency from

anywhere in the world as the application is developed for ANDROID mobile. The

security will not be compromised in this application and the results will be out in very

less time as there won’t be any delay in this automated process.

1.4 LIMITATIONS OF THE PROJECT

People who are illiterate can’t use this application.

Every user should have an ANDROID mobile phone which might not be possible

in our country.

Every user needs to have minimum computer knowledge without which there will

be difficulty in casting their vote.

1.5 ORGANIZATION OF DOCUMENTATION

In this project documentation we have initially put the definition and objective of

the project as well as the design of the project which is followed by the implementation

and testing phases. Finally the project has been concluded successfully and also the future

enhancements of the project were given in this documentation.

2

2. LITERATURE SURVEY

2.1 INTRODUCTION

Unique identification project was initially conceived by the Planning Commission

as an initiative that would provide identification for each resident across the country and

would be used primarily as the basis for efficient delivery of welfare services. It would

also act as a tool for effective monitoring in Election system in our country (MP, MLA,

Municipal, and Panchayath), Based on the user information he will get a password to

android mobile, using this password he can vote for the election. So the election

process become much more easier for the election commission. It is very feasible to the

user as he can vote from anywhere in the world.

2.2 EXISTING SYSTEM

Present Election System is based on the Electronic voting system or ballot voitng, for

polling initially a committee verifies the persons for authentication that is purely based on

the manual system and verifies voter identity card for authentication. Developed

countries like United States of America are already using these kinds of applications

2.3 DISADVANTAGES OF EXISTING SYSTEM

Manual system

Long process for authenticating voters

There may be chance of rigging

Voting machines are vulnerable and can be tampered.

Results will be released after a long span.

Highly unsecured process

3

2.4 PROPOSED SYSTEM

The Proposed system is an automated process; Elections will be online based and

provides security for the polling by authenticating the persons based on the UIDAI

number which is provided by the government. Based on the user information we will

send a secured number to mobile (android), using this secured number user will vote for

his preferred politician city wise.

2.5 CONCLUSION

We can overcome all the drawbacks of the existing system by using this

application on ANDROID mobile. In this application the key which is generated based on

the valid user is very secure and can be used only once. This key is said to be UIDAI key.

The results can be obtained in very less time as there won’t be any delay in counting

votes in the database.

4

3. ANALYSIS

3.1 NTRODUCTION

After analyzing the requirements of the task to be performed, the next step is to

analyze the problem and understand its context. The first activity in the phase is studying

the existing system and other is to understand the requirements and domain of the new

system. Both the activities are equally important but the first activity serves as a basis of

giving the functional specifications and then successful design of the proposed system.

Understanding the properties and requirements of a new system is more difficult and

requires creative thinking as well as understanding of existing system is also difficult.

Improper understanding of present system can lead diversion from solution.

Feasibility Report

All projects are feasible – given unlimited resources and infinite time!

Unfortunately, the development of computer-based system or product is more likely

plagued by a scarcity of resources and difficult delivery dates. It is both necessary and

prudent to evaluate the feasibility of a project at the earliest possible time. Months or

years of effort, thousands or millions of dollars, and untold professional embarrassment

can be averted if an ill-conceived system is recognized early in the definition phase.

Feasibility and risk analysis are related in many ways. If project risk is great the

feasibility of producing quality software is reduced. During product engineering,

however, we concentrate our attention on four primary areas of interest:

5

Technical Feasibility

The Android SDK includes a comprehensive set of development tools.

Requirements include Java Development Kit, the officially supported integrated

development environment (IDE) is Eclipse (3.2 or later) using the Android Development

Tools (ADT) Plug in, though developers may use any text editor to edit Java and XML

files then use command line tools to create, build and debug Android applications.

Information System is developed on android platform so that it can be deployed on any

android powered mobile phone. The application uses Google Map API. The application

should be authenticated to avail maps in the project.

ANDROID Software development kit:

The Android SDK includes a comprehensive set of development tools. These

include a debugger, libraries, a handset emulator (based on QEMU), documentation,

sample code, and tutorials. Currently supported development platforms include x86-

architecture computers running Linux (any modern desktop Linux distribution), Mac OS

X 10.4.8 or later, Windows XP or Vista. Requirements also include Java Development

Kit, Apache Ant, and Python 2.2 or later. The officially supported integrated

development environment (IDE) is Eclipse (3.2 or later) using the Android Development

Tools (ADT) Plugin, though developers may use any text editor to edit Java and XML

files then use command line tools to create, build and debug Android applications.

This application in going to be used in an Internet environment called www (World

Wide Web). So, it is necessary to use a technology that is capable of providing the

networking facility to the application. This application is also able to work on distributed

environment. Application on developed with J2EE (Java 2 Enterprise Edition platform)

Technology. One major advantage in application is platform neutral. We can deploy and

used it in any operating system.

6

GUI is developed using HTML.to capture the information from the customer.

HTML is used to display the content on the browser. It uses HTTP protocol. It is an

interpreted language. It is very easy to develop a page/document using HTML some RAD

(Rapid Application Development) tools are provided to quickly design/develop our

application. So many objects such as button, text fields, and text area etc are providing to

capture the information from the customer.

We can use this application in any OS. They can have their own security and

transactional advantages. But are the responsible for selecting suitable and secured OS,

which is suitable to our application.

The back-end Mysql and front-end application are platform independent. So we

can port this enterprise application in any environment. Both are having their individual

configuration to get better performance and backup issues.

Economical Feasibility

To decide whether a project is economically feasible, we have to consider various

factors as:

Cost benefit analysis

Long-term returns

Maintenance costs

In present system voter need to go to polling booth to vote. So he/she needs to

spend some time to complete this protocol.

If it is developed to vote through internet, He can vote from anywhere in the

world. No need to travel to polling both.

7

Operational Feasibility

In our application front end is developed using GUI. So it is very easy to the voter

to enter the necessary information. But voter has some knowledge on using web

applications before going to use our application.

Analysis Model

First of all, the feasibility study is done. Once that part is over, the requirement

analysis and project planning begins. If system exists as a whole but modification and

addition of new module is needed, analysis of present system can be used as basic model.

The design starts after the requirement analysis is complete and the coding begins after

the design is complete. Once the programming is completed, the testing is done. In this

model the sequence of activities performed in a program development project are:

1. Requirement Analysis

2. Project Planning

3. System Design

4. Detail Design

5. Coding

6. Unit Testing

7. System Integration & Testing

Here the linear ordering of these activities is critical. At the end of the phase, the

output of one phase is the input to other phase. The output of each phase should be

consistent with the overall requirement of the system. Some of the qualities of spiral

model are also incorporated like after the people concerned with the project review

completion of each of the phase the work done.

Water fall Model has been chosen because all requirements were known

before and the objective of our software development is the computerization automation

of an already existing manual working system.

8

Fig: Waterfall Model

9

3.2 SOFTWARE REQUIREMENT SPECIFICATION

The main purpose of preparing this document is to give a general insight into

the analysis and requirements of the existing system or situation and for determining

the operating characteristics of the system.

This Document plays a vital role in the Software Development Life Cycle(SDLC)

and it describes the complete requirements of the system. It is meant to be used by the

developers and will be the basic concept during the testing phase. Any changes made to

the requirements in the future will have to go through formal change approval process.

3.2.1 User requirement

The user needs a complex and a very secure key (UIDAI key) that has to be

generated in the application based on the user information such as his name, address,

email-id, education and many other fields.

The user needs an application where he can login using a secure key and vote for

the politician of his choice for his constituency. The user also wants to see the results on

the mobile in a very short span of time after the election.

3.2.2 Software requirement

Web Server : Tomcat 5.5

Server-side Technologies : Java, Java Server Pages, servlets

Client-side Technologies : HTML, CSS, JAVA SCRIPT ,AJAX

IDE : Eclipse

Database Server : My SQL

10

Operating System : Windows

SDK : Android 2.2

JAVA

Java is a programming language 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 has a simpler object model and fewer low-level facilities.

Java applications are typically compiled to “byte code” (class file) that can run on any

Java Virtual Machine (JVM) regardless of computer architecture. Java is a general-

purpose, concurrent, class-based, object-oriented language that is 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 is currently one of the

most popular programming languages in use, particularly for client-server web

applications, with a reported 10 million users.

The original and reference implementation Java compilers, virtual machines, and

class libraries were developed by Sun from 1995. As of May 2007, in compliance with

the specifications of the Java Community Process, Sun relicensed most of its Java

technologies under the GNU General Public License. Others have also developed

alternative implementations of these Sun technologies, such as the GNU Compiler for

Java and GNU class path.

Java is related to C++, which is a direct descendent of C. Much of the

character of Java is inherited from these two languages. From C, Java derives its

syntax. Many of Java’s object-oriented features were influenced by C++. In fact,

several of Java’s defining characteristics come from or are responses to its

predecessors. Moreover, the creation of Java was deeply rooted in the process of

11

refinement and adaptation that has been occurring in computer programming

languages for the past three decades. For these reasons, this section reviews the sequence

of events and forces that led up to Java. As you will see, each innovation in language

design was driven by the need to solve a fundamental problem that the preceding

languages could not solve. Java is no exception.

The Internet helped catapult Java to the forefront of programming, and Java, in

turn, has had a profound effect on the Internet. The reason for this is quite simple: Java

expands the universe of objects that can move about freely in cyberspace. In a network,

two very broad categories of objects are transmitted between the server and your personal

computer: passive information and dynamic, active programs. Forexample, when you

read your e-mail, you are viewing passive data. Even when you download a program, the

program’s code is still only passive data until you execute it.

However, a second type of object can be transmitted to your computer: a

dynamic,

self-executing program. Such a program is an active agent on the client computer, yet is

initiated by the server. For example, a program might be provided by the server to display

properly the data that the server is sending. As desirable as dynamic, networked programs

are, they also present serious problems in the areas of security and portability. Prior to

Java, cyberspace was effectively closed to half the entities that now live there.

Java Overview

Java is a powerful but lean object-oriented programming language. It has

generated a lot of excitement because it makes it possible to program for Internet by

creating Applets. Programs that can be embedded in web page. The context of an applet

can be an animation with sound, an interactive game or a ticker tape. With constantly

updated stock prices. Applets can be just little decorations to liven up web page, or they

can be serious applications like Word processor or Spreadsheet

.

But Java is more than a programming language for writing Applets. It is being

12

used more and more for writing standalone applications as well. It is becoming so

popular that many people believe it will become standard language for both general

purpose and Internet programming.

There are many buzzwords associated with Java, but because of its spectacular

growth in popularity, a new buzzword has appeared ubiquitous. Indeed, all indications

are that it will soon be everywhere.

Java builds on the strength of C++. It has taken the best features of C++ and discarded

the more problematic and error prone parts. To this lean core, it has added garbage

collection (automatic memory management), multithreading (the capacity for one

program to do more than one thing at a time), security capabilities. This result is that Java

is simple, elegant, and powerful and easy-to-use. Java is actually a platform consisting of

3 components:

Java Programming Language.

Java Library of Classes and Interfaces.

Java Virtual Machine

Java is portable

One of the biggest advantages Java offers is that it is portable. An application

written in Java will run on all the major platforms. Any computer with a Java-based

browser can run the applications or Applets written in the Java-Programming- Language.

A programmer no longer has to write one program to run on a Macintosh, another

program to run on a windows-machine still another to run on a UNIX machine and so on.

In other words, with Java developers write their programs only once.

The Virtual Machine is what gives Java is cross platform capabilities. Rather

being compiled into machine language, which is different for each OS’s and computer

architecture, Java code is compiled into Byte codes. With other languages, the program

code is compiled into a language that the computer can understand. The problem is that

13

other computers with different machine instruction set cannot understand that language.

Java code on the other hand is compiled into Byte-Code rather than a machine language.

These byte codes go to the JVM, which executes them directly or translates them into the

language that is understood by the machine running it.

In summary, these means that with the JDBC API extending Java, a programmer

writing Java code can access all the major RDBMS on any platform that supports the

JVM.

Java is Object – oriented

The Java programming language is OBJECT-ORIENTED, which makes

program design focus on what you are dealing with, rather than on how you are going

to do something. This makes it more useful for programming in sophisticated projects,

because one can break the things into understandable components. A big benefit is

that these components can then be reused.

Object-Oriented Languages use the paradigm of classes. In simplest term, a class

includes both the data and the functions to operate on data. You can create an instance of

a class, also called an object, which will have all the data members and functionality of

its class. Because of this, you can think of a class as being like template, with each object

being a specific instance of a particular type of class.

The class paradigm allows one to encapsulate data so that specific data values are

those using the data cannot see the function implementation. Encapsulation makes it

possible to make the changes in code without breaking other programs that use that code.

If for example, the implementation of a function is changed, the change is invisible to

any programmer who invokes that function, and does not affect his/her program, except

hopefully to improve it.

Java includes inheritance, or the ability to derive new classes from existing

classes. The derived class, is also called as Sub-Class, inherits all the data in the

14

functions of the existing class. Let us discuss about the Java buzz words.

Simple

We wanted to build a system that could be programmed easily without a lot of esoteric

training and which leveraged today's standard practice. Most programmers working

these days use C and most programmers doing object-oriented programming use C++. So

even though we found that C++ was unsuitable, we designed Java as closely to C++ as

possible in order to make the system more comprehensible. Java omits many rarely used,

poorly understood, confusing features of C++ that in our experience bring more grief

than benefit. These omitted features primarily consist of operator overloading (although

the Java language does have method overloading), multiple inheritance, and extensive

automatic coercions.

We added automatic garbage collection, thereby simplifying the task of Java

programming but making the system somewhat more complicated. A common source

of complexity in many C and C++ applications is storage management: the allocation and

freeing of memory. By virtue of having automatic garbage collection (periodic freeing of

memory not being referenced) the Java language not only makes the programming task

easier, it also dramatically cuts down on bugs.

The folks at Archimedes wanted to spend their time thinking about levers and pulleys,

but instead spent a lot of time on mundane programming tasks. Their central expertise

was teaching, not programming. One of the most complicated of these programming

tasks was figuring out where memory was being wasted across their 20K lines of code.

Another aspect of being simple is being small. One of the goals of Java is to enable the

construction of software that can run stand-alone in small machines. The Java interpreter

and standard libraries have a small footprint. A small size is important for use in

embedded systems and so Java can be easily downloaded over the net.

15

Object-Oriented

This is, unfortunately, one of the most overused buzzwords in the industry. But

object-oriented design is very powerful because it facilitates the clean definition of

interfaces and makes it possible to provide reusable "software ICs." Simply stated,

object-oriented design is a technique that focuses design on the data (objects) and on the

interfaces to it. To make an analogy with carpentry, an "object-oriented" carpenter would

be mostly concerned with the chair he was building, and secondarily with the tools used

to make it; a "non-object-oriented" carpenter would think primarily of his tools. Object-

oriented design is also the mechanism for defining how modules "plug and play."

The object-oriented facilities of Java are essentially those of C++, with extensions

from Objective C for more dynamic method resolution. The folks at Archimedes had lots

of things in their simulation, among them ropes and elastic bands. In their initial C

version of the product, they ended up with a pretty big system because they had to write

separate software for describing ropes versus elastic bands. When they rewrote their

application in an object-oriented style, they found they could define one basic object that

represented the common aspects of ropes and elastic bands, and then ropes and elastic

bands were defined as variations (subclasses) of the basic type. When it came time to add

chains, it was a snap because they could build on what had been written before, rather

than writing a whole new object simulation.

Network-Savvy

Java has an extensive library of routines for coping easily with TCP/IP protocols

like TTP and FTP. This makes creating network connections much easier than in C or

C++. Java applications can open and access objects across the net via URLs with the

same ease that programmers are used to when accessing a local file system.

The folks at Archimedes initially built their stuff for CD ROM. But they had some ideas

for interactive learning games that they wanted to try out for their next product. For

example, they wanted to allow students on different computers to cooperate in building a

16

machine to be simulated. But all the networking systems they'd seen were complicated

and required esoteric software specialists. So they gave up.

RobustJava is intended for writing programs that must be reliable in a variety of ways. Java puts a

lot of emphasis on early checking for possible problems, later dynamic (runtime) checking,

and eliminating situations that are error prone. One of the advantages of a strongly typed

language (like C++) is that it allows extensive compile-time checking so bugs can be found

early. Unfortunately, C++ inherits a number of loopholes in compile-time checking from C,

which is relatively lax (particularly method/procedure declarations). In Java, we require

declarations and do not support C-style implicit declarations.

The linker understands the type system and repeats many of the type checks done by

the compiler to guard against version mismatch problems. The single biggest difference

between Java and C/C++ is that Java has a pointer model that eliminates the possibility of

overwriting memory and corrupting data. Instead of pointer arithmetic, Java has true arrays.

This allows subscript checking to be performed. In addition, it is not possible to turn an

arbitrary integer into a pointer by casting.

The folks at Archimedes had their application basically working in C pretty quickly.

But their schedule kept slipping because of all the small bugs that kept slipping through.

They had lots of trouble with memory corruption, versions out-ofsync and interface

mismatches. What they gained because C let them pull strange tricks in their code, they paid

for in quality assurance time. They also had to reissue their software after the first release

because of all the bugs that slipped through. While Java doesn't make the QA problem go

away, it does make it significantly easier.

Very dynamic languages like Lisp, TCL and Smalltalk are often used for prototyping.

One of the reasons for their success at this is that they are very robust: you don't have to

worry about freeing or corrupting memory. Java programmers can be relatively fearless about

dealing with memory because they don't have to worry about it getting corrupted. Because

there are no pointers in Java, programs can't accidentally overwrite the end of a memory

17

buffer. Java programs also cannot gain unauthorized access to memory, which could happen

in C or C++. One reason that dynamic languages are good for prototyping is that they don't

require you to pin down decisions too early. Java uses another approach to solve this

dilemma; Java forces you to make choices explicitly because it has static typing, which the

compiler enforces. Along with these choices comes a lot of assistance: you can write method

invocations and if you get something wrong, you are informed about it at compile time. You

don't have to worry about method invocation error.

Secure

Java is intended for use in networked/distributed environments. Toward that end, a lot of

emphasis has been placed on security. Java enables the construction of virus-free, tamper-free

systems. The authentication techniques are based on public key encryption. There is a strong

interplay between "robust" and "secure." For example, the changes to the semantics of

pointers make it impossible for applications to forge access to data structures or to access

private data in objects that they do not have access to. This closes the door on most activities

of viruses.

Someone wrote an interesting "patch" to the PC version of the Archimedes system.

They posted this patch to one of the major bulletin boards. Since it was easily available and

added some interesting features to the system, lots of people downloaded it. It hadn't been

checked out by the folks at Archimedes, but it seemed to work. Until the next April 1st, when

thousands of folks discovered rude pictures popping up in their children's lessons. Needless

to say, even though they were in no way responsible for the incident, the folks at Archimedes

still had a lot of damage to control.

Architecture NeutralJava was designed to support applications on networks. In general, networks

are composed of a variety of systems with a variety of CPU and operating system

architectures. To enable a Java application to execute anywhere on the network, the

compiler generates an architecture-neutral object file format--the compiled code is executable

on many processors, given the presence of the Java runtime system. This is useful not only

for networks but also for single system software distribution. In the present personal

computer market, application writers have to produce versions of their application that are

compatible with the IBM PC and with the Apple Macintosh. With the PC market (through

18

Windows/NT) diversifying into many CPU architectures, and Apple moving off the 680x0

toward the PowerPC, production of software that runs on all platforms becomes nearly

impossible. With Java, the same version of the application runs on all platforms.

The Java compiler does this by generating bytecode instructions which have

nothing to do with a particular computer architecture. Rather, they are designed to be

both easy to interpret on any machine and easily translated into native machine code

on the fly.

Archimedes is a small company. They started out producing their software for

the PC since that was the largest market. After a while, they were a large enough

company that they could afford to do a port to the Macintosh, but it was a pretty big

effort and didn't really pay off. They couldn't afford to port to the PowerPC Macintosh

or MIPS NT machine. They couldn't "catch the new wave" as it was happening, and a

competitor jumped in...

Portable

Being architecture neutral is a big chunk of being portable, but there's more to it than

that. Unlike C and C++, there are no "implementation dependent" aspects of the

specification. The sizes of the primitive data types are specified, as is the behavior of

arithmetic on them. For example, "int" always means a signed two's complement 32 bit

integer, and "float" always means a 32-bit IEEE 754 floating point number. Making these

choices is feasible in this day and age because essentially all interesting CPUs share these

characteristics. The libraries that are a part of the system define portable interfaces. For

example, there is an abstract Window class and implementations of it for Unix, Windows

NT/95, and the Macintosh. The Java system itself is quite portable. The compiler is written in

Java and the runtime is written in ANSI C with a clean portability boundary. The portability

boundary is essentially a POSIX subset.

InterpretedJava byte codes are translated on the fly to native machine instructions (interpreted)

and not stored anywhere. And since linking is a more incremental and light weight process,

19

the development process can be much more rapid and exploratory. As a part of the byte code

stream, more compile-time information is carried over and available at runtime. This is what

the linker's type checks are based on. It also makes programs more amenable to debugging.

The programmers at Archimedes spent a lot of time waiting for programs to compile

and link. They also spent a lot of time tracking down senseless bugs because some changed

source files didn't get compiled (despite using a fancy "make" facility), which caused version

mismatches; and they had to track down procedures that were declared inconsistently in

various parts of their programs. Another couple of months lost in the schedule.

High Performance

While the performance of interpreted byte codes is usually more than adequate, there

are situations where higher performance is required. The byte codes can be translated on the

fly (at runtime) into machine code for the particular CPU the application is running on. For

those accustomed to the normal design of a compiler and dynamic loader, this is somewhat

like putting the final machine code generator in the dynamic loader.

The bytecode format was designed with generating machine codes in mind, so

the actual process of generating machine code is generally simple. Efficient code is produced:

the compiler does automatic register allocation and some optimization when it produces the

bytecodes. In interpreted code we're getting about 300,000 method calls per second on an

Sun Microsystems SPARCStation 10. The performance of bytecodes converted to machine

code is almost indistinguishable from native C or C++.

When Archimedes was starting up, they did a prototype in Smalltalk. This

impressed the investors enough that they got funded, but it didn't really help them

produce their product: in order to make their simulations fast enough and the system

small enough, it had to be rewritten in C.

Multithreaded

There are many things going on at the same time in the world around us.

Multithreading is a way of building applications with multiple threads. Unfortunately, writing

programs that deal with many things happening at once can be much more difficult than

20

writing in the conventional single-threaded C and C++ style. Java has a sophisticated set of

synchronization primitives that are based on the widely used monitor and condition variable

paradigm introduced by C.A.R.Hoare By integrating these concepts into the language (rather

than only in classes) they become much easier to use and are more robust. Much of the style

of this integration came from Xerox's Cedar/Mesa system.

Other benefits of multithreading are better interactive responsiveness and real-time

behavior. This is limited, however, by the underlying platform: stand-alone Java runtime

environments have good real-time behavior. Running on top of other systems like Unix,

Windows, the Macintosh, or Windows NT limits the real-time responsiveness to that of the

underlying system. Lots of things were going on at once in their simulations. Ropes were

being pulled, wheels were turning, levers were rocking, and input from the user was being

tracked. Because they had to write all this in a single threaded form, all the things that

happen at the same time, even though they had nothing to do with each other, had to be

manually intermixed. Using an "event loop" made things a little cleaner, but it was still a

mess. The system became fragile and hard to understand. They were pulling in data from all

over the net. But originally they were doing it one chunk at a time. This serialized network

communication was very slow. When they converted to a multithreaded style, it was trivial to

overlap all of their network communication.

DynamicIn a number of ways, Java is a more dynamic language than C or C++. It was

designed to adapt to an evolving environment. For example, one major problem with C++ in

a production environment is a side-effect of the way that code is implemented. If company A

produces a class library (a library of plug and play components) and company B buys it and

uses it in their product, then if A changes its library and distributes a new release, B will most

certainly have to recompile and redistribute their own software. In an environment where the

end user gets A and B's software independently (say A is an OS vendor and B is an

application vendor) problems can result.

For example, if A distributes an upgrade to its libraries, then all of the software from

B will break. It is possible to avoid this problem in C++, but it is extraordinarily difficult and

it effectively means not using any of the language's OO features directly.

21

Archimedes built their product using the object-oriented graphics library from

3DPC Inc. 3DPC released a new version of the graphics library which several

computer manufacturers bundled with their new machines. Customers of Archimedes

that bought these new machines discovered to their dismay that their old software no

longer worked. (In real life, backwards compatibility isn't always a high priority in the

Unix world. In the PC world, 3DPC would never have released such a library: their

ability to change their product and use C++'s object oriented features is severely

hindered because they can't expect their customers to recompile.)

Java Development Environment

To code, edit, debug and test the java programs, one needs to have a java

development environment. At the minimum this will consists of a java compiler interpreter

and applet viewer where applets can be tested. Sun’s java development kit (JDK) latest

version is 2.2 can be freely downloaded from the Internet. Java compiler is available on DOS,

Win95, WIN’NT, Solaris and MAC etc. Data flow diagram is a graphical tool used to

describe analyze the movement of data through a system manual or automated including the

processes, stores of data, and delays in the system. Data flow diagrams are the central tool

and basis for form which other components are developed. The data flow diagram is also

known a data flow graph or bubble chart.

Automatic memory management

Java uses an automatic garbage collector to manage memory in the object lifecycle.

The programmer determines when objects are created, and the Java runtime is responsible

for recovering the memory once objects are no longer in use. Once no references to an object

remain, the unreachable memory becomes eligible to be freed automatically by the garbage

collector. Something similar to a memory leak may still occur if a programmer's code holds a

reference to an object that is no longer needed, typically when objects that are no longer

needed are stored in containers that are still in use. If methods for a nonexistent object are

called, a "null pointer exception" is thrown.

22

One of the ideas behind Java's automatic memory management model is that

programmers can be spared the burden of having to perform manual memory management. In

some languages, memory for the creation of objects is implicitly allocated on the stack, or

explicitly allocated and deallocated from the heap. In the latter case the responsibility of

managing memory resides with the programmer. If the program does not deallocate an

object, a memory leak occurs. If the program attempts to access or de-allocate memory that

has already been de-allocated, the result is undefined and difficult to predict, and the program

is likely to become unstable and/or crash. This can be partially remedied by the use of smart

pointers, but these add overhead and complexity. Note that garbage collection does not

prevent "logical" memory leaks, i.e. those where the memory is still referenced but never

used. Garbage collection may happen at any time. Ideally, it will occur when a program is

idle. It is guaranteed to be triggered if there is insufficient free memory on the heap to

allocate a new object; this can cause a program to stall momentarily. Explicit memory

management is not possible in Java.

Java does not support C/C++ style pointer arithmetic, where object addresses and

unsigned integers (usually long integers) can be used interchangeably. This allows the

garbage collector to relocate referenced objects and ensures type safety and security.

As in C++ and some other object-oriented languages, variables of Java's primitive

data types are not objects. Values of primitive types are either stored directly in fields (for

objects) or on the stack (for methods) rather than on the heap, as commonly true for objects

(but see Escape analysis). This was a conscious decision by Java's designers for performance

reasons. Because of this, Java was not considered to be a pure object-oriented programming

language. However, as of Java 5.0, auto boxing enables programmers to proceed as if

primitive types were instances of their wrapper class.

Java contains multiple types of garbage collectors. By default, Hot Spot uses the

Concurrent Mark Sweep collector, also known as the CMS Garbage Collector. However,

there are also several other garbage collectors that can be used to manage the Heap. For 90%

of applications in Java, the CMS Garbage Collector is good enough.

23

Java Versions

The initial release of Java was nothing short of revolutionary, but it did not

mark the end of Java’s era of rapid innovation. Unlike most other software systems

that usually settle into a pattern of small, incremental improvements, Java continued to

evolve at an explosive pace. Soon after the release of Java 1.0, the designers of Java had

already created Java 1.1. The features added by Java 1.1 were more significant and

substantial than the increase in the minor revision number would have you think. Java 1.1

added many new library elements, redefined the way events are handled by applets, and

reconfigured many features of the 1.0 library. It also deprecated (rendered obsolete)

several features originally defined by Java 1.0. Thus, Java 1.1 both added and subtracted

attributes from its original specification.

The next major release of Java was Java 2. Java 2 was a watershed event,

Marking the beginning of the “modern age” of this rapidly evolving language! The

first release of Java 2 carried the version number 1.2. It may seem odd that the first

release of Java 2 used the 1.2 version number. The reason is that it originally referred

to the version of the Java libraries, but it was generalized to refer to the entire release,

itself. Java 2 added support for a number of new features, such as Swing and the

Collections framework, and it enhanced the Java Virtual Machine and various

programming tools.

Java 2 also contained a few deprecations. The most important affected the

Thread class in which the methods suspend( ), resume( ), and stop( ) were deprecated. The

next release of Java was Java 2, version 1.3. This version of Java was the first major upgrade

to the original Java 2 release. For the most part it added to existing functionality and

“tightened up” the development environment. In general, programs written for version 1.2

and those written for version 1.3 are source-code compatible. Although version 1.3 contained

a smaller set of changes than the preceding three major releases, it was nevertheless

important. The current release of Java is Java 2, version 1.4. This release contains several

important upgrades, enhancements, and additions. For example, it adds the new keyword

assert, chained exceptions, and a channel-based I/O subsystem. It also makes changes to the

24

Collections Framework and the networking classes. In addition, numerous small changes are

made throughout. Despite the significant number of new features, version

1.4 maintains nearly 100 percent source-code compatibility with prior versions.

ANDROID

Android is a software stack for mobile devices that includes an operating system,

middleware and key applications. The android SDK provides the tools and APIs necessary to

begin developing applications on the Android platform using the Java programming language.

Features

Application framework enabling reuse and replacement of components

Dalvik virtual machine optimized for mobile devices

Integrated browser based on the open source Web Kit engine

Optimized graphics powered by a custom 2D graphics library; 3D graphics based on the

OpenGL ES 1.0 specification (hardware acceleration optional)

SQLite for structured data storage

Media support for common audio, video, and still image formats (MPEG4, H.264, MP3, AAC,

AMR, JPG, PNG, and GIF)

GSM Telephony (hardware dependent)

Bluetooth, EDGE, 3G, and Wi-Fi (hardware dependent)

Camera, GPS, compass, and accelerometer (hardware dependent)

Rich development environment including a device emulator, tools for debugging, memory and

performance profiling, and a plug in for the Eclipse IDE

Android application

Developers have full access to the same framework APIs used by the core applications.

The application architecture is designed to simplify the reuse of components; any application can

publish its capabilities and any other application may then make use of those capabilities (subject

25

to security constraints enforced by the framework). This same mechanism allows components to

be replaced by the user.

Libraries

Android includes a set of C/C++ libraries used by various components of the Android

system. These capabilities are exposed to developers through the Android application framework.

Some of the core libraries are listed below:

System C library - a BSD-derived implementation of the standard C system library (libc), tuned

for embedded Linux-based devices

Media Libraries - based on Packet Video’s Open CORE; the libraries support playback and

recording of many popular audio and video formats, as well as static image files, including

MPEG4, H.264, MP3, AAC, AMR, JPG, and PNG

Surface Manager - manages access to the display subsystem and seamlessly composites 2D and

3D graphic layers from multiple applications

Lib Web Core - a modern web browser engine which powers both the Android browser and an

embeddable web view

SGL - the underlying 2D graphics engine

3D libraries - an implementation based on OpenGL ES 1.0 APIs; the libraries use either

hardware 3D acceleration (where available) or the included, highly optimized 3D software

rasterizer

Free Type - bitmap and vector font rendering

SQLite - a powerful and lightweight relational database engine available to all applications

Android Runtime

Android includes a set of core libraries that provides most of the functionality available in

the core libraries of the Java programming language.

Every Android application runs in its own process, with its own instance of the Dalvik

virtual machine. Dalvik has been written so that a device can run multiple VMs efficiently. The

Dalvik VM executes files in the Dalvik Executable format which is optimized for minimal

26

memory footprint. The VM is register-based, and runs classes compiled by a Java language

compiler that have been transformed into the .dex format by the included "dx" tool.

The Dalvik VM relies on the Linux kernel for underlying functionality such as threading

and low-level memory management.

An Android code editor that helps you write valid XML for your Android manifest and

resource files.

It will even export your project into a signed APK, which can be distributed to users.

To begin developing Android applications in the Eclipse IDE with ADT, you first need to

download the Eclipse IDE and then download and install the ADT plugin.

Developing in eclipse with ADT:

The Android Development Tools (ADT) plug-in for Eclipse adds powerful extensions to the Eclipse integrated development environment. It allows you to create and debug Android applications easier and faster. If you use Eclipse, the ADT plug-in gives you an incredible boost in developing Android applications:

It gives you access to other Android development tools from inside the Eclipse IDE. For

example, ADT lets you access the many capabilities of the DDMS tool: take screenshots, manage

port-forwarding, set breakpoints, and view thread and process information directly from Eclipse.

It provides a New Project Wizard, which helps you quickly create and set up all of the

basic files you'll need for a new Android application.

It automates and simplifies the process of building your Android application.

Creating an Android project

The ADT plugin provides a New Project Wizard that you can use to quickly create a new

Android project (or a project from existing code). To create a new project:

1. Select File > New > Project.

2. Select Android > Android Project, and click Next.

3. Select the contents for the project:

Enter a Project Name. This will be the name of the folder where your project is created.

27

Under Contents, select Create new project in workspace. Select your project workspace

location.

Under Target, select an Android target to be used as the project's Build Target. The Build Target

specifies which Android platform you'd like your application built against.

Unless you know that you'll be using new APIs introduced in the latest SDK, you should select a

target with the lowest platform version possible, such as Android 1.1.

Note: You can change your the Build Target for your project at any time: Right-click the

project in the Package Explorer, select Properties, select Android and then check the

desired Project Target.

Under Properties, fill in all necessary fields.

Enter an Application name. This is the human-readable title for your application — the name that

will appear on the Android device.

Enter a Package name. This is the package namespace (following the same rules as for packages

in the Java programming language) where all your source code will reside.

Select Create Activity (optional, of course, but common) and enter a name for your main Activity

class.

Enter a Min SDK Version. This is an integer that indicates the minimum API Level required to

properly run your application. Entering this here automatically sets the minSdkVersion attribute in

the <uses-sdk> of your Android Manifest file. If you're unsure of the appropriate API Level to

use, copy the API Level listed for the Build Target you selected in the Target tab.

4. Click Finish.

Once you complete the New Project Wizard, ADT creates the following folders and files

in your new project:

src/

Includes your stub Activity Java file. All other Java files for your application go here.

<Android Version>/ (e.g., Android 1.1/)

28

Includes the android.jar file that your application will build against. This is determined by

the build target that you have chosen in the New Project Wizard.

gen/

This contains the Java files generated by ADT, such as your R.java file and interfaces

created from AIDL files.

assets/

This is empty. You can use it to store raw asset files. See Resources and Assets.

res/

A folder for your application resources, such as drawable files, layout files, string values,

etc. See Resources and Assets.

AndroidManifest.xml

The Android Manifest for your project. See The AndroidManifest.xml File.

Default. Properties

This file contains project settings, such as the build target. This files is integral to the

project, as such, it should be maintained in a Source Revision Control system. It should

never be edited manually — to edit project properties, right-click the project folder and

select "Properties".

Running your application:

Before you can run your application on the Android Emulator, you must create an

Android Virtual Device (AVD). An AVD is a configuration that specifies the Android

platform to be used on the emulator. You can read more in the Android Virtual Devices

document, but if you just want to get started, follow the simple guide below to create an

AVD.

29

If you will be running your applications only on actual device hardware, you do not need

an AVD — see Developing On a Device for information on running your applicaiton.

Internet

The Internet helped catapult Java to the forefront of programming and Java in turn has had a

profound effect on the Internet. The reason is simple: Java expands the universe of objects that

can move about freely in cyberspace. In a network, there are two broad categories of objects

transmitted between the Server and your Personal Computer: passive information and dynamic,

active programs like an object that can be transmitted to your computer, which is a dynamic, self-

executing program. Such a program would be an active agent ton the client computer, yet the

server would initiate it. As desirable as dynamic, networked programs are, they also present

serious problems in the areas of security and portability. Prior to Java cyberspace was effectively

closed to half the entities that now live there. Java addresses these concerns and doing so, has

opened the door to an exiting a new form of program.

The rise of server-side Java applications is one of the latest and most exciting trends in Java

programming. It was first hyped as a language for developing elaborate client-side web content in

the form of applets. Now, Java is coming into its own as a language ideally suited for server-side

development. Businesses in particular have been quick to recognize Java’s potential on the

server-Java is inherently suited for large client/server applications. The cross platform nature of

Java is extremely useful for organizations that have a heterogeneous collection of servers running

various flavors of the Unix of Windows operating systems. Java’s modern, object-oriented,

memory-protected design allows developers to cut development cycles and increase reliability.

In addition, Java’s built-in support for networking and enterprise API provides access to legacy

data, easing the transition from older client/server systems.

Java Servlets are a key component of server-side java development. A Servlets is a small,

plug gable extension to a server that enhances the server’s functionality. Servlets allow

developers to extend and customize and Java enabled server a web server, a mail server, an

30

application server, or any custom server with a hitherto unknown degree of portability, flexibility

and ease.

JAVA SERVER PAGE (JSP)

Java Server Pages is a simple, yet powerful technology for creating and maintaining

dynamic-content web pages. Based on the Java programming language, Java Server Pages

offers proven portability, open standards, and a mature re-usable component model.

PORTABILITY

Java Server Pages files can be run on any web server or web-enabled application

server that provides support for them. Dubbed the JSP engine, this support involves

recognition, translation and management of the Java Server Pages lifecycle and its interaction

with associated components.

The JSP engine for a particular server might be built-in or might be provided through

a 3rd –party add-on. As long as the server on which you plan to execute the Java Server Pages

supports the same specification level as that to which the file was written, no change should

be necessary as you move your files from server to server. Note, however, that instructions

for the setup and configuration of the files may differ between files.

COMPOSITION

It was mentioned earlier that the Java Server Pages architecture could include

reusable Java components. The architecture also allows for the embedding of a scripting

language directly into the Java Server Pages file. The components current supported include

Java Beans and Serves. As the default scripting language, Java Server Pages use the Java

Programming language. This means that scripting on the server side can take advantage of the

full set of capabilities that the Java programming language offers.

PROCESSING

A Java Server Pages file is essentially an HTML document with JSP scripting

or tags. It may have associated components in the form of. class, .jar, or .ser files- -or

it may not. The use of components is not required.

31

Browser

Bean

JSP

Request

Response

The Java Server Pages file has a .jsp extension to identify it to the server as a

Java Server Pages file. Before the page is served, the Java Server Pages syntax is

parsed and processed into a servlet on the server side. The servlet that is generated,

outputs real content in straight HTML for responding to the customer. Because it is

standard HTML, the dynamically generated response looks no different to the

customer browser than a static response.

ACCESS MODELS: A Java Server Pages file may be accessed in at least two

different ways: A client request comes directly into a Java Server Page.

Figure1. Access Models

In this scenario, suppose the page accessed reusable Java Bean components

that perform particular well-defined computations like accessing a database. The

result of the Bean’s computations, called result sets is stored within the Bean as

properties. The page uses such Beans to generate dynamic content and present it back

to the client. A request comes through a servlet.

32

Result Bean

JDBC

Figure2. Data Transfer Processing

The servlet generates the dynamic content. To handle the response to the client, the

servlet creates a Bean and stores the dynamic content (sometimes called the result set) in the

Bean. The servlet then invokes a Java Server Page that will present the content along with the

Bean containing the generated from the servlet.

There are two APIs to support this model of request processing using Java Server

Pages. One API facilitates passing context between the invoking servlet and the Java Server

Page. The other API lets the invoking servlet specify which Java Server Page to use.

In both of the above cases, the page could also contain any valid Java code. The Java

Server Pages architecture separation of content from presentation- -it does not mandate it.

JDBC requires that the SQL statements be passed as Strings to Java methods. For

example, our application might present a menu of database tasks from which to choose. After

a task is selected, the application presents prompts and blanks for filling information needed

to carry out the selected task. With the requested input typed in, the application then

automatically invokes the necessary commands.

In this project we have implemented three-tier model, commands are sent to a

“middle tier” of services, which then send SQL statements to the database. The database

process the SQL statements and sends the results back to the middle tier, which then sends

them to the user. JDBC is important to allow database access from a Java middle tier.

JDBC

JDBC is a Java API for executing SQL statements. (As a point of interest, JDBC

is a trademarked name and is not an acronym; nevertheless, JDBC is often thought of as

standing for "Java Database Connectivity".) It consists of a set of classes and interfaces

written in the Java programming language. JDBC provides a standard API for

33

BeanRequest

Response

Database

tool/database developers and makes it possible to write database applications using a pure

Java API.

Using JDBC, it is easy to send SQL statements to virtually any relational

database. In other words, with the JDBC API, it isn't necessary to write one program to

access a Sybase database, another program to access an Oracle database, another program

to access an Informix database, and so on. One can write a single program using the

JDBC API, and the program will be able to send SQL statements to the appropriate

database. And, with an application written in the Java programming language, one also

doesn't have to worry about writing different applications to run on different platforms.

The combination of Java and JDBC lets a programmer write it once and run it anywhere.

Java being robust, secure, easy to use, easy to understand, and automatically

downloadable on a network, is an excellent language basis for database applications.

What is needed is a way for Java applications to talk to a variety of different databases.

JDBC is the mechanism for doing this.

JDBC extends what can be done in Java. For example, with Java and the JDBC

API, it is possible to publish a web page containing an applet that uses information

obtained from a remote database. Or an enterprise can use JDBC to connect all its

employees (even if they are using a conglomeration of Windows, Macintosh, and UNIX

machines) to one or more internal databases via an intranet. With more and more

programmers using the Java programming language, the need for easy database access

from Java is continuing to grow.

MIS managers like the combination of Java and JDBC because it makes

disseminating information easy and economical. Businesses can continue to use their

installed databases and access information easily even if it is stored on different database

management systems. Development time for new applications is short. Installation and

version control are greatly simplified. A programmer can write an application or an

update once, put it on the server, and everybody has access to the latest version. And for

businesses selling information services, Java and JDBC offer a better way of getting out

information updates to external customers.

34

CONNECTION

A connection object represents a connection with a database. A connection

session includes the SQL statements that are executed and the results that are returned

over the connection. A single application can have one or more connections with a

single database, or it can have connections with many different databases.

OPENING A CONNECTION

The standard way to establish a connection with a database is to call the

method DriverManager.getConnection. This method takes a string containing a URL.

The Driver Manager class, referred to a the JDBC management layer, attempts to

locate a driver than can connect to the database represented Driver classes, and when

the method get Connection is called, it checks with each driver in the list until it finds one

that can connect uses this URL to actually establish the connection.

<Sub protocol>-usually the driver or the database connectivity mechanism, which

may be supported by one or more drivers. A prominent example of a sub protocol name is

“oracle”, which has been reserved for URLs that specify “thin”-style data source names.

<Sub name>- a way to identify the database. The sub names can vary,

depending on the sub protocol, and it can have a sub name with any internal syntax

the driver writer chooses. The point of a sub name is to give enough information to

locate the database.

SENDING STATEMENT

Once a connection is established, it is used to pass SQL statements to its

underlying database. JDBC does not put any restrictions on the kinds of SQL

statements that can be sent; this provides a great deal of flexibility, allowing the use of

database-specific statements or even non-SQL statements. It requires, however, that

the user be responsible for making sure that the underlying database can process the

SQL statements being sent and suffer the consequences if it cannot.

DRIVER MANAGER

35

The Driver Manager class is the management layer of JDBC, working between

the user and the drivers. It keeps track of the drivers that are available and handles

establishing a connection between a database and the appropriate driver. It addition,

the driver manager class attends to things like driver login time limits and the printing

of log and tracing messages. The only method in this class that a general programmer

needs to use directly is DriverManager.getConnection. As its name implies, this

method establishes a connection to a database.

A JAVA2 Platform, Enterprise Edition Deployment

36

Figure 3 Java 2 Platform

3.2.3 Hardware requirements

Processor: Pentium-II (or) Higher

Ram: 512MB (or) Higher

Cache: 512MB

Hard disk: 10GB

3.3 ALGORITHM

Take the user information

Form a key based on the user information like name, date of birth ,education , location

Give it to the user

Accept the user as a valid one by comparing the information with the official data available.

User can vote using the key generated by the random number generator.

3.4 CONCLUSION

In this phase, we understand the software requirement specifications for the

project. We arrange all the required components to develop the project in this phase

itself so that we will have a clear idea regarding the requirements before designing the

project. Thus we will proceed to the design phase followed by the implementation

phase of the project.

37

4. DESIGN

4.1 INTRODUCTION

System design is transition from a user oriented document to programmers or data

base personnel. The design is a solution, how to approach to the creation of a new

system. This is composed of several steps. It provides the understanding and procedural

details necessary for implementing the system recommended in the feasibility study.

Designing goes through logical and physical stages of development, logical design

reviews the present physical system, prepare input and output specification, details of

implementation plan and prepare a logical design walkthrough.

The database tables are designed by analyzing functions involved in the

system and format of the fields is also designed. The fields in the database tables should

define their role in the system. The unnecessary fields should be avoided because it

affects the storage areas of the system. Then in the input and output screen design, the

design should be made user friendly. The menu should be precise and compact.

SOFTWARE DESIGN

In designing the software following principles are followed:

1. Modularity and partitioning: software is designed such that, each system should consists of

hierarchy of modules and serve to partition into separate function.

2. Coupling: modules should have little dependence on other modules of a system.

3. Cohesion: modules should carry out in a single processing function.

38

4. Shared use: avoid duplication by allowing a single module be called by other that need the

function it provides.

4.2 DFD AND UML DIAGRAMS

DATA FLOW DIAGRAMS

A Data Flow Diagram (DFD) is a graphical technique that depicts information flow and

the transforms that are applied as data move from input to output.

Data flow diagram is a logical model of a system. The model does not depend on

hardware, software, and data structure or file organization. It only shows the data flow between

modules to module of the entire system. Data flow diagrams can be completed using only four

notations as follows,

Data Flow Diagrams are of two types:

Physical Data Flow Diagrams

These are implementation-dependent i.e., they show the actual devices,

departments, people, etc., involved in the system.

Logical Data Flow Diagrams

These diagrams describe the system independently of how it is actually

implemented, they show what takes places, rather than how an activity is accomplished.

Data Flow

Data move in a specific direction from an origin to destination. The data flow is a

“packet” of data.

39

Process

People, procedures or devices that produce data. The physical component is not

identified.

Source or Destination of Data

External sources or destinations of data, which may be people or organizations or

other entities.

Data Source

Here a process references the data in the system

40

DFD DIAGRAMS:

(CONTEXT LEVEL-DFD)

LEVEL 1 DFD:

Request Request Send Request

Send Response Response

41

User 0.0

USER REGITRATION

Stored In DataBase

User

Mobile

Process

Web Application

Database

LEVEL 2 DFD:

Send Response

42

1. Login Process

USER

1.1

SEND MOBILE

1.2

WEB APPLICATION DATABASE

Request

Response

UML DIAGRAMS

Class diagram

Figure 4. Class Diagram for Effectual key for uidai based voting in android.

43

1. Login Process

Use Case Diagram for Android

Figure 5 Use case Diagram for Effectual key for uidai based voting in android.

44

Use Case Diagram for Administrator

Figure6. Use case for Diagram for Administrator

45

Use case Diagram for Voter

Figure7. Use case Diagram for Voter

46

Use case diagram for Nominee

Figure8. Use case Diagram for Nominee

47

Sequence diagram for Admin

Figure 9.. Sequence Diagram for Admin

48

Sequence diagram for Voter

Figure 10. Sequence Diagram for Voter

4.3 MODULE DESIGN AND ORGANIZATION

The major modules of the project are

1. Security Module

49

2 .Voter’s maintenance module

3 Nominee maintenance modules

4. Voting module

5. Result Analysis module

6. Authentication

7. Taking uidai number

8. Getting voting information

9. Vote for politician

10. Viewing results

11. Receiving secure number from android phone

1. Security Module

This module provides the security to the voting process i.e. any unauthorized person

cannot vote. Authentication of the voter is done in this module so that the voting process

is done in appropriate manner. This module authenticates the voter identity by validating

his/her details furnished. During the voter registration against the data provided by the

election authority.

2. Voter’s maintenance module

This module maintains the voter’s details such as voter id, voter name, voter division, and

voter address.

1. Registration

2. Login

3. Change password

4. Vote

3. Nominee maintenance module

This module maintains the nominee details such as nominee id, nominee name,

nominee address and party name.

50

1. Registration

2. Login

3. Select division

4. Select party

5. Logout

4. Voting module

This module maintains the hoe many voters are voted. By voter is voting to

nominee the following criteria doing as given below.

1. Login

2. Vote

3. Enter voter id

4. Select division

5. Vote

6. Logout

5. Result Analysis module

This module maintains the result view. In the module maintained the votes by the

nominee individually and give the output who is the win particular division. This

module maintained by admin only but all the people are view the result at voting

time because of it is web based system.

6. Authentication

The process of recognize the people by government by using the persons id

that person will be the authenticated person.

7. Taking uidai number

51

In this module the authenticated person will get the unique identification

authority of India (uidai) key to the android cell. The user will take the key.

8. Getting voting information

In this module the user will get the voting information about the politicians like

which politician is participating for this area what is the symbol for that politician.

9. Vote for politician

In this module by using the uidai key the user will vote the politician.

10. Viewing results

In this module the user can able to see the previous results of the politicians.

11. receiving secure number from android phone

The secure number will get in to an android cell by using that id the user will vote

the politician on internet.

DATABASE TABLES

REGISTRATION

Field Name Data Type Constraints

Vid Int(11) NOT NULL

Name VARCHAR(20) NOT NULL

Password VARCHAR(100) NOT NULL

Table4.2.1. Registration Table

Voter List

52

Field Name Data Type Constraints

id Int(!0) NOT NULL

name VARCHAR(15) NOT NULL

password VARCHAR(15) NOT NULL

f_name VARCHAR(10) NOT NULL

DoB VARCHAR(10) NOT NULL

divid VARCHAR(10) NOT NULL

address VARCHAR(10) NOT NULL

Table4.2.2. Voter List Table

NOMINEE LIST

Field Name Data Type Constraints

n id Int(!0) NOT NULL

name VARCHAR(15) NOT NULL

Partyid Int(!0) NOT NULL

divid Int(!0) NOT NULL

Address VARCHAR(15) NOT NULL

Table4.2.3. Nominee List Table

4.4 CONCLUSION

In this way we can design the layout of the project which is to be implemented

during the construction phase. Thus we will have a clear picture of the project before

being coded. Hence any necessary enhancements can be made during this phase and

53

coding can be started

5. IMPLEMENTATION AND RESULTS

5.1 INTRODUCTION

The implementation part is the most important phase of the project. In this phase,

we code the entire project in the chosen program according to the design laid during the

previous phase. The code has to be in such a way that the user requirements are satisfied

and also not complicated for the user. The code should be efficient in all terms like space,

easy to update, etc. In this manner, we can complete the coding part of the project and

later it can be sent for testing

5.2 EXPLANATION OF KEY FUNCTIONS

Generation of KEY(UIDAI )

UUID idOne = UUID.randomUUID();String hai=idOne.toString();String u=name.substring(0,3);String u5=u.toUpperCase();String u1=hai.substring(0,7);String u4=u1.toUpperCase();String u2=hai.substring(26,32);

54

String u3=u2.toUpperCase();String key=u5+u3+u4;

5.3 METHOD OF IMPLEMENTATION

The implementation of this application is majorly concerned with the generation

of effectual key for UIDAI based voting application on ANDROID. Here as you can see

the generation of this key is done by the function randomUUID();

Initially, the user will register himself and gets the key, the admin verifies wether the user

is genuine person or not and then he accepts him as genuine voter. Now, user votes using

this UIDAI key and he can also see the results.

5.3.1 Forms

There is a registration form for the user in this project. This form is has various

fields like name, password, email-id, phone number, guardian, age, date of birth, PIN

number , address ,gender etc.Using the details filled by the user on this form the random

number gets generated. The user can vote using this number after getting verified by the

admin. So, this form is crucial as some of its fields are used for generating the key on the

“ANDROID”.

5.3.2 Output Screens

This is the user Home page for Login and Registration for new user

55

If user clicks on new user the below page will be displayed

56

57

58

After clicking on registration button the below screen displayed with udai number

59

60

Admin logins in the above page

This is the home page for Admin

61

Admin can add the Divisions here

After adding the below screen displayed

62

Here admin can view the requested users who are willing to vote and he can accept or reject.

After getting the acceptance from the admin then only user can login .

63

After the user login page the below page display for new user voting

64

After clicking on the nominee name the below details for that particular nominee is displaying

65

Then new user can vote that particular person

If the user wants to vote again it will not be possible

66

When User clicks on the results the below page will be display

67

68

5.3.3 Result Analysis

Here the generation of a secured key is an important part of this

application which is done successfully in our application. Using this key user can vote

only once and there won’t be any duplication of votes or rigging in our application.

.

5.4 CONCLUSION

In this way, we have successfully implemented our project by using ANDROID

SDK and JSP. Using this application user can vote from any part of the world and can

view the results in a very less time after the results..

69

6. TESTING AND VALIDATION

6.1. INTRODUCTION

Software testing is a critical element of software quality assurance and represents

the ultimate review of specification, design and code generation. Software testing is a

process of executing given software with an intention of finding bugs in it.It is one of the

essential steps in software development life cycle. The code developed must be error free.

The code must have structural, functional simplicity. There are several testing phase such

as Unit testing, Integration testing, Validation testing, System testing.

A strategy for software testing integrates software test case design methods into a

well-planned series of steps that result in the successful construction of software. Testing

is the set of activities that can be planned in advance and conducted systematically. The

underlying motivation of program testing is to affirm software quality with methods that

can economically and effectively apply to both strategic to both large and small-scale

systems.

The following are Testing Objectives

To ensure that during operation the system will perform as per specification.

TO make sure that system meets the user requirements during operation

To make sure that during the operation, incorrect input, processing and output

will be detected

To see that when correct inputs are fed to the system the outputs are correct

To verify that the controls incorporated in the same system as intended

Testing is a process of executing a program with the intent of finding an error

A good test case is one that has a high probability of finding an as yet

undiscovered error

The software developed has been tested successfully using the following testing

strategies and any errors that are encountered are corrected and again the part of the

program or the procedure or function is put to testing until all the errors are removed.

70

A successful test is one that uncovers an as yet undiscovered error.

Note that the result of the system testing will prove that the system is working correctly.

It will give confidence to system designer, users of the system, prevent frustration during

implementation process etc.

6.2 DESIGN OF TEST CASES & SCENARIO

The objective is to design tests that systematically uncover different classes of

errors and do so with a minimum amount of time and effort. Testing cannot show the

absence of defects, it can only show that software defects are present.

White box testing

White box testing is a testing case design method that uses the control structure of

the procedure design to derive test cases. All independents path in a module are exercised

at least once, all logical decisions are exercised at once, execute all loops at boundaries

and within their operational bounds exercise internal data structure to ensure their

validity. Here the customer is given three chances to enter a valid choice out of the given

menu. After which the control exits the current menu.

Black Box Testing

Black Box Testing attempts to find errors in following areas or categories,

incorrect or missing functions, interface error, errors in data structures, performance error

and initialization and termination error. Here all the input data must match the data type

to become a valid entry.

The following are the different tests at various levels:

Unit Testing

Unit testing is essentially for the verification of the code produced during the

coding phase and the goal is test the internal logic of the module/program. In the

Generic code project, the unit testing is done during coding phase of data entry

forms whether the functions are working properly or not. In this phase all the

drivers are tested they are rightly connected or not.

71

Interface

Number of input parameters should be equal to number of arguments.

Parameter and argument attributes must match.

Parameters passed should be in correct order.

Global variable definitions consistent across module.

If module does I/O,

File attributes should be correct.

Open/Close statements must be correct.

Format specifications should match I/O statements.

Buffer Size should match record size.

Files should be opened before use.

End of file condition should be handled.

I/O errors should be handled.

Any textual errors in output information must be checked.

Local Data Structures (common source of errors!)

Improper or inconsistent typing.

Erroneous initialization or default values.

Incorrect variable names.

Inconsistent date types.

Overflow, underflow, address exceptions.

Boundary conditions and Independent paths

Error Handling

Error description unintelligible.

Error noted does not correspond to error encountered.

Error condition handled by system run-time before error handler gets

control.

Exception condition processing incorrect.

Integration Testing

72

All the tested modules are combined into sub systems, which are then tested.

The goal is to see if the modules are properly integrated, and the emphasis being on the

testing interfaces between the modules. In the generic code integration testing is done

mainly on table creation module and insertion module. Modules integrated by moving

down the program design hierarchy. Can use depth first or breadth first top down

integration verifies major control and decision points early in design process. Top-level

structure tested most. Depth first implementation allows a complete function to be

implemented, tested and demonstrated and does depth first implementation of critical

functions early. Top down integration forced (to some extent) by some development tools

in programs with graphical user interfaces. Begin construction and testing with atomic

modules (lowest level modules).Bottom up integration testing as its name implies begins

construction and testing with atomic modules. Because modules are integrated from the

bottom up, processing required for modules subordinate to a given level is always

available and the need for stubs is

eliminated.

Validation Testing

Validation testing is aims to demonstrate that the software functions in a manner that can

be reasonably expected by the customer. This tests conformance the software to the

Software Requirements Specification. This testing concentrates on confirming that the

software is error-free in all respects. All the specified validations are verified and the

software is subjected to hard-core testing. It also aims at determining the degree of

deviation that exists in the software designed from the specification; they are listed out

and are corrected

Validation Test Criteria

A set of black box test is to demonstrate conformance with requirements. To check that

all functional requirements satisfied, all performance requirements achieved,

documentation is correct and ' human-engineered', and other requirements are met (e.g.

compatibility, error recovery, and maintainability). When validation tests fail it may be

73

too late to correct the error prior to scheduled delivery. Need to negotiate a method of

resolving deficiencies with the customer.

Configuration Review

An audit to ensure that all elements of the software configuration are properly developed

catalogued and has all the necessary detail to support maintenance.

Alpha and Beta Testing

It is difficult to anticipate how users will really use software. If there is one customer, a

series of acceptance tests are conducted (by the customer) to enable the customer to

validate all requirements. If software is being developed for use by multiple customers,

cannot use acceptance testing. An alternative is to use alpha and beta testing to uncover

errors. A customer conducts alpha testing at the developer's site. The customer uses the

software with the developer 'looking over the shoulder' and recording errors and usage

problems. Alpha testing conducted in a controlled environment. Beta testing is conducted

at one or more customer sites by end users. It is ‘live’ testing in an environment not

controlled by developer. The customer records and reports difficulties and errors at

regular intervals.

System Testing

Software is only one component of a system. Software will be incorporated with other

system components and system integration and validation test performance. This testing

concentrates on confirming that the software is error-free in all respects. All the specified

validations are verified and the software is subjected to hard-core testing. It also aims at

determining the degree of deviation that exists in the software designed from the

specification; they are listed out and are corrected.

74

6.3 VALIDATION

Validation aims to demonstrate that the software functions in a manner that can be

reasonably expected by the customer. This tests conformance the software to the software

requirements Specification. Here this project has done for developing an application by

which peope can vote in a secured manner with least vulnerability.

6.4 CONCLUSION

In this way we also completed the testing phase of the project and ensured that the

application is ready to be deployed. By doing so we have developed a very secured

voting application.

75

7. CONCLUSION

By this project, we can overcome the drawbacks of the existing system of voting in elections. This project deals with the security issues like authentication of the users and approving the valid users to login based on the key that is generated in ANDROID. Hence, we can conclude that this application will be useful in conducting the elections and calculating the results.

This application can be further enhanced in the future when more number of smart phones get introduced in the market and this application can be used throughout the world. Then, people residing in foreign countries can cast their vote and enjoy their Right to Vote from any part of the world.

76

REFERENECS

Advanced Java Programming - Dietel and Dietel

Mastering JAVA 2 - John Zukowski

Java Server Programming - Apress

Software Engineering - Roger S Pressman

Análysis & Design of InformationSystems – Senn

www.android-trainer.com.

77