status representation for message using android application

1

CHAPTER 1

INTRODUCTION

1.1 ABOUT THE PROJECT

“Status Representation for Message Using Android Application “is an

application shows the message status for the receiver message that whether the

message is viewed by the user or not. A person can send a SMS from the application

and can also able to view the unread SMS from the application.

The mobile phone users are increase day by day and everyone wants to develop

new things which is improved version of existing one. The SMS user might want the

faster SMS technology which can convert their voice into text through the Google

voice recognition API and SMS will be transferred.

This project based on evaluating voice versus keypad as a means for entry and

editing of texts. In other words, we can say messages can be voice/speech typed. It is

found that large-vocabulary speech recognition can offer a very competitive alternative to

traditional text entry.

In this application we will receive the SMS from the person with the help of

broadcast receiver. The SMS can be received in this application itself, whenever an incoming

SMS comes from other person.

It has additional feature of viewing status of the SMS send by the person. If the

receiver view’s the message then the status of the SMS is send programmatically to the

sender with the particular SMS substring of 30 character along with the SMS status. Thus,

the sender know about the particular SMS is being viewed by the receiver.

2

CHAPTER 2

LITERATURE REVIEW

2.1 LITERATURE REVIEW

Literature survey is the documentation of a comprehensive review of the

published and unpublished work from secondary sources data in the areas of specific

interest to the researcher.

M. Tomalin, F. Diehl, M.J.F. Gale–s, J. Park & P.C. Woodland, “Recent

Improvements To The Cambridge Arabic Speech-To-Text Systems”, ICASSP

2010 pp 4382-4385

This paper describes recent improvements to the Cambridge Arabic Large

Vocabulary Continuous Speech Recognition (LVSCR) Speech-to-Text (STT) system. It

is shown that Multi-Layer Perceptron (MLP) features trained on phonetic targets can

improve the performance of both phonemic and graph emic systems. Also, a

morphological decomposition scheme is extended from the graph emic domain to the

phonetic domain, and particular attention is given to the task of dictionary generation.

Finally, the use of Boosted Maximum Mutual Information (BMMI) training is explored

both for individual systems and in the context of system combination. The full system

results show that the combined use of the above techniques reduces the Word Error Rate

(WER) of the best individual system by up to 12% relative, and that the incorporation of

morphological decomposition and BMMI within the four individual branches of the

combined system reduces the WER by up to 9% relative.

Ryuichi Nisimura, Jumpei Miyake, Hideki Kawahara and Toshio Irino,

“Speech-To-Text Input Method For Web System Using Javascript”, IEEE SLT

2008 pp 209-212

We have developed a speech-to-text input method for web systems. The system is

provided as a JavaScript library including an Ajax-like mechanism based on a Java

applet, CGI programs, and dynamic HTML documents. It allows users to access voice-

enabled web pages without requiring special browsers. Web developers can embed it on

3

their web page by inserting only one line in the header field of an HTML document. This

study also aims at observing natural spoken interactions in personal environments. We

have succeeded in collecting 4,003 inputs during a period of seven months via our public

Japanese ASR server. In order to cover out-of-vocabulary words to cope with some

proper nouns, a web page to register new words into the language model are developed.

As a result, we could obtain an improvement of 0.8% in the recognition accuracy. With

regard to the acoustical conditions, an SNR of 25.3 dB was observed.

Panikos Heracleous, Hiroshi Ishiguro and Norihiro Hagita, “Visual-

speech to text conversion applicable to telephone communication for deaf

individuals” 18th International Conference on Telecommunication

2011. pp 130-133

The access to communication technologies has become essential for the

handicapped people. This study introduces the initial step of an automatic translation

system able to translate visual speech used by deaf individuals to text, or auditory speech.

A such a system would enable deaf users to communicate with each other and with

normal-hearing people through telephone networks or through Internet by only using

telephone devices equipped with simple cameras. In particular, this paper introduces

automatic recognition and conversion to text of Cued Speech for French. Cued speech is

a visual mode used for communication in the deaf society. Using hand shapes placed in

different positions near the face as a complement to lipreading, all the sounds of a spoken

language can be visually distinguished and perceived. Experimental results show high

recognition rates for both isolated word and continuous phoneme recognition experiments

in Cued Speech for French.

Y.Liu, E.Shriberg, A.Stolcke, D.Hillard, M.Ostendorf, and M.Harper,

“Enriching speech recognition with automatic detection of sentence boundaries

and disfluencies,” IEEE Trans. Audio, Speech, Lang. Process., vol. 14, no. 5,

pp. 1524–1538, Sep. 2006.

Effective human and automatic processing of speech requires recovery of more

than just the words. It also involves recovering phenomena such as sentence boundaries,

filler words, and disfluencies, referred to as structural metadata. We describe a metadata

4

detection system that combines information from different types of textual knowledge

sources with information from a prosodic classifier. We investigate maximum entropy

and conditional random field models, as well as the predominant hidden Markov model

(HMM) approach, and find that discriminative models generally outperform generative

models. We report system performance on both broadcast news and conversational

telephone speech tasks, illustrating significant performance differences across tasks and

as a function of recognizer performance. The results represent the state of the art, as

assessed in the NIST RT-04F evaluation.

5

CHAPTER 3

PROBLEM DEFINITION

3.1 PROBLEM DEFINITION

While many Android SMS application can only able to send and receive SMS at a

time. Using Google voice recognition API and SMS will be transferred. Thus, many

problems had difficulty making their products interoperable. Existing system don’t have

any SMS status feature for opened SMS.

3.1.1 EXISTING SYSTEM

In the existing system, Android SMS application does not have any status features

for the SMS opened in order to identify that the end user is viewing the particular SMS

currently.

DRAWBACK OF EXISTING SYSTEM

Seen SMS status, along with the prefix of SMS information 30 character can be

send to sender.

Unseen important SMS can be viewed on time.

Prevent cheating / fraud activities by SMS viewing status.

3.1.2 PROBLEM RECOGINIZATION

The Android SMS application refer to the information send and receive to the

user, the existing system enable the feature and technology being developed, the various

task such as application to develop the android apps. The application to develop for SMS

status Representation using android. It commonly known as SMS Opened Status

Representation system. Once the user send the SMS to other user, he / she can able to

know about the SMS viewing status along the 30 character prefix of the SMS being send

to the particular user when he / she opens.

6

3.1.3 PROPOSED SYSTEM

This is a SMS status Representation for Android application being developed to

know the SMS status of the opened message either viewed or unseen by the user along

with the prefix 30 character of the SMS being send to the particular user.

3.2 FEATURES

The Proposed System has been developed with the certain features which more

help for the users,

Converting Speech to Text

Display Open status of the SMS

3.3 OVERALL GOALS

The Overall goals of our project is to allow the users to access a well-versed SMS

application. The new application addresses the problems to avoid the important unread

SMS. And also to assure the SMS has been viewed on right time by the person.

7

CHAPTER 4

SOFTWARE REQUIREMENT SPECIFICATION

4.1 INTRODUCTION

An SRS is basically an organization’s understanding (in writing) of a customer or

potential client’s system requirements and dependencies at a particular point in time

(usually) prior to any actual design or development work. Software Requirement

Specification has been developed for future reference in case of any ambiguity and

misunderstanding. SRS provides a detailed description of the requirement, behaviors,

constraints and performance of the system.

4.2 REQUIREMENT ANALYSIS

Requirement Analysis is for transformation of operational need into software

description, software performance parameter, and software configuration through use of

standards, iterative process of analysis and trade –off studies for understanding what the

customer wants, analysis need, assessing feasibility, negotiating a reasonable solution,

validation the specification, and managing the requirements.

4.2.1 PURPOSE

The purpose of this document is to have review, to ensure that the developer and

the customer have the same perception of the system. This document is an agreement

made between the customers and the software developers/designers concerning about the

functional and the nonfunctional requirements that the software system should reveal. In

addition, it will also provide the specific requirements and functionality needed for this

project- such as interface, functional requirements and performance requirements.

4.2.2 SCOPE

The scope of this Software Requirement Specification states that the goals and

objectives of the software describing it in the context of the computer based systems.

8

This document is used to throughput the project life cycle right from the inception to the

final stage of implementation. This statement defines the requirement of the systems,

function and non-functional, by the users and developers. It is referred as in case any

ambiguities or confusion arise, the developer is responsible for asking clarification

whenever necessary and won’t make any alterations without the permission of the client.

4.2.3 OVERVIEW

The Software Requirement Specification document for the system covers the

following two sections,

General Descriptions – It provides the general description about the

project. It includes description about the product function, user

characteristics and general constraints.

Specification Requirements – This section describes about both the

functional and non-functional requirements of the system.

The Functional Requirements section defines the system

requirement specification from functionalities point view.

The Non-Functional Requirements section defines the system’s

external interface, general requirements, performance, design

constraints, etc. which are dealt with detail in corresponding sub-

sections.

4.2.4 GENERAL DESCRIPTIONS

The general description provides an overview about the functional areas of the

project, which we are developed. This section describes the general functionality desired

in common terms. It describes product perspectives, product function, user’s

characteristics, general constraints and all the assumptions and dependencies.

Information content flow and structure are also documented.

9

4.2.4.1 PRODUCT FUNCTION

The project is guaranteed to provide reliable results and the functionality of the

product is to give a wide range of flexibility to the user in a secured and accurate way.

The user interface is provided in terms of various modules for the users.

4.2.4.2 USER CHARACTERISTICS

The user of the project have some basic knowledge to operate the android mobile

application and also able to follow the system instruction which is English. The important

thing is that he should be administrator to benefit the all feature in the application being

present.

User

User can install this application then run similar operating system phone this

application on android mobile device can send and receive the SMS along with the status

of the SMS information.

4.2.4.3 GENERAL CONSTRAINTS

The general description provides an overview about the functional areas of the

project, which we are developed. This section describes the general functionality desired

in common terms. It describes product perspectives, product function, user’s

characteristics, general constraints and all the assumptions and dependencies.

Information content flow and structure are also documented.

The product runs only on Android operating system.

There is no hardware limitation.

The user must know how to operate android mobile devices.

10

4.2.5 FUNCTIONAL REQUIREMENTS

Functional requirement are expressed in relational and state oriented notation that

specify relationships among inputs, actions and output in the applications. In this system

services such as reliability, performance, availability, usability, adaptability and

extensibility.

4.2.5.1 TECHNICAL ISSUES

Safe external access

Updating new application and functionality

4.2.5.2 RISK ANALYSIS

Risks are potential problems that might affect the successful completion of a

software project. The risk of using this product is that if the system is already optimized

with some other tool then there is a chance of system crash. If this product is used in

their operating system some functionality may work properly and some may not have

taken all the common features from its parent OS. Once the system is crashed due to

wrong usage of this tool then it is not possible to work without reinstalling the whole

system again.

I used Spiral Model for the Risk Analysis, in that I analyzed the risks before

starting each and every module from the client.

Gather information of current existing systems.

Design the flow of the application. How it is going to function.

Design the interface of the application.

Code a simple SMS application.

Further enhance the application with more functions.

Combine everything up and test runs it to ensure no bug and error.

Test the application on different types of mobile phones. Find out the OS needed

to get all the functions working. Try to further improve the system if possible

11

4.2.6 INTERFACE REQUIREMENTS

This system defines interaction modes in a way that does not force a user into

undesired actions. The user can access the system with little or no effort through the

software. The flexible different interaction preference can be specified in the hardware

equipment. For the support of good interface a system should have the hardware and

software equipment.

4.2.6.1 HARDWARE REQUIREMENTS

Processor : Dual Core

RAM : 1 GB

Hard disk : 120 GB and above

Monitor : 14 inch

Keyboard : Standard Keyboard

Mouse : Optical Mouse

4.2.6.2 SOFTWARE REQUIREMENTS

Operating System : Windows, Android

Tools : Android Development Kit, Eclipse

Virtual Machine : Android (2.3)

12

CHAPTER 5

OBJECT ORIENTED ANALYSIS

5.1 ELEMENTS OF ANALYSIS MODEL

An object contains encapsulated data and procedures grouped together to represent

an entity. The 'object interface', how the object can be interacted with, is also defined. An

object-oriented program is described by the interaction of these objects. Object-oriented

design is the discipline of defining the objects and their interactions to solve a problem that

was identified and documented during object-oriented analysis. It generates models of the

problem domain classes like the Use case, Sequential, Activity and Class diagram that are

present in the system.

5.1.1 USE CASES AND USE CASE DIAGRAM

A use case diagram in the Unified Modeling Language (UML) is a type of

behavioral diagram defined by and created from a Use-case analysis. Its purpose is to

present a graphical overview of the functionality provided by a system in terms of actors,

their goals (represented as use cases), and any dependencies between those use cases. The

main purpose of a use case diagram is to show what system functions are performed for

which actor.

13

The Use case diagram is used to define the core elements and processes that make

up a system. The key elements are termed as "actors" and the processes are called "use

cases." The Use case diagram shows which actors interact with each use case.

OVERALL USECASE DIAGRAM FOR SYSTEM

USECASE : Overall Process

DESCRIPTION: The figure 4.1 shows the overall system

Fig.: 5.1 Overall Use case Diagram

USE CASE DESCRIPTION

Compose SMS The Sender / Receiver can create / compose new SMS

Send SMS The Sender / Receiver can send an SMS

Receive SMS The Sender / Receiver receive an SMS

View SMS The Sender / Receiver can view unread SMS

View SMS Open Status The Sender can identify unread SMS status

14

USECASE DIAGRAM FOR SENDER MODULE

USECASE : Sender Module

ACTOR : Sender (User)

DESCRIPTION: The figure 4.2 shows the operations of sender module

Fig.:5.2 Use Case Diagram For Sender Module


Compose SMS The Sender can create / compose new SMS

Send SMS The Sender can send an SMS

Receive SMS The Sender receive an SMS

View SMS The Sender can view unread SMS

View SMS Open Status The Sender can identify unread SMS status

15

USECASE DIAGRAM FOR RECEIVER MODULE

USECASE : Receiver Module

ACTOR : Receiver (User)

DESCRIPTION: The figure 4.3 shows the operations of receiver module

Fig.:5.3 Use Case Diagram For Receiver Module


Compose SMS The Receiver can create / compose new SMS

Send SMS The Receiver can send an SMS

Receive SMS The Receiver receive an SMS

View SMS The Receiver can view unread SMS

16

5.1.2 SEQUENCE DIAGRAM

A sequence diagram models a dynamic view of the interaction between model

elements at run time. Sequence diagrams are commonly used as explanatory model for

use case scenario.

An actor element may be used to represent the user initiating the flow of events.

Stereotyped elements, such as boundary, control and entity may be used to illustrate

screens, controller items respectively.

OVERALL SEQUENCE DIAGRAM OF THE SYSTEM

Fig.:5.4 Overall Sequence Diagram

The figure 5.4 illustrates the overall sequence diagram of overall system. Sender,

Associate, Receiver attribute for evaluation of a process.

17

5.1.3 ACTIVITY DIAGRAM

Activity diagrams are used to model the behavior of the system and the way in

which the behaviors are related in the overall flow of the system. The activity diagram

depicts the logical path, process flow based on various conditions which are used to

construct a process, system or procedure.

Fig.:5.5 Overall Activity Diagram

The figure 5.5 illustrates the overall activity diagram of the system. User can Send

and Receive / View the SMS through the application.

18

5.1.4 ENTITY RELATIONSHIP DIAGRAM

Entity Relationship (ER) diagram is a graphical representation of entities and their

relationships to each other, typically used in computing in regard to the organization

of data within databases or information systems. An entity is a piece of data-an object or

concept about which data is stored. A relationship is how the data is shared between

entities. There are three types of relationships between entities:

One-to-one: one instance of an entity (A) is associated with one other instance of

another entity (B). For example, in a database of employees, each employee name (A) is

associated with only one social security number (B).

One-to-many: one instance of an entity (A) is associated with zero, one or many

instances of another entity (B), but for one instance of entity B there is only one instance

of entity A. For example, for a company with all employees working in one building, the

building name (A) is associated with many different employees (B), but those employees

all share the same singular association with entity A.

Many-to-many: one instance of an entity (A) is associated with one, zero or

many instances of another entity (B), and one instance of entity B is associated with one,

zero or many instances of entity A. For example, for a company in which all of its

employees work on multiple projects, each instance of an employee (A) is associated

with many instances of a project (B), and at the same time, each instance of a project (B)

has multiple employees (A) associated with it.

Building Blocks of ER Diagram

Entity: an object that is involved in the enterprise and that be distinguished from other

objects. (Not shown in the ER diagram--is an instance). It can be physical object or

abstraction

Entity Type: set of similar objects or a category of entities; they are well defined.

Attribute: describes one aspect of an entity type; usually [and best when] single valued

and indivisible (atomic)

http://www.webopedia.com/TERM/D/data.html

http://www.webopedia.com/TERM/D/database.html

http://www.webopedia.com/TERM/O/object.html

19

May be multi-valued – use double oval on E-R diagram

May be composite – attribute has further structure; also use oval for composite

attribute, with ovals for components connected to it by lines

May be derived – a virtual attribute, one that is computable from existing data in

the database, use dashed oval. This helps reduce redundancy

Symbols for ER Diagram

Entity – rectangle

Attribute – oval

Relationship – diamond

Link – line

Fig. 5.6: Over All Entity Relationship diagram

The figure 5.6 represents the Overall Entity Relationship diagram for SMS

application, which shows the various attributes or fields of an entity and the relationship.

20

CHAPTER 6

OBJECT ORIENTED DESIGN

Object-oriented design is a design strategy where system designers think in terms

of‘Things’ instead of operations or functions. The executing system is made up

ofinteracting objects that maintain their own local state and provide operations on

thatstate information .They hide information about the representation ofthe state and

hence limit access to it. An object-oriented design process involvesdesigning the object

classes and the relationships between these classes.

Object-oriented design is part of object-oriented developmentwhere anobject-

oriented strategy is used throughout the development process:

Object-oriented analysisis concerned with developing an object-oriented model

of the application domain. The identified objects reflect entities and operations

that are associated with the problem to be solved.

Object-oriented designis concerned with developing an object-oriented model of

a software system to implement the identified requirements. The objects in an

object-oriented design are related to the solution to the problem that is being

solved. There may be close relationships between some problem objects and some

solution objects but the designer inevitably has to add new objects and to

transform problem objects to implement the solution.

Object-oriented programmingis concerned with realizing a software design

using an object-oriented programming language. An object-oriented programming

language, such as Java, supports the direct implementation of objects and

provides facilities to define object classes.

Objects are potentially reusable components because they are

independentencapsulations of state and operations. Designs can be developed using

21

objects thathave been created in previous designs. This reduces design, programming

andvalidation costs.

6.1 ARCHITECTURE DESIGN

Service oriented architecture is a very popular architecture paradigm for designing

and developing distributed system. It is as information technology approach in which

applications make use of services available in a network such as the world wide web.

It is an architectural style where system consist of service consumers and service

providers. An architecture style defines a vocabulary of components and connectors

type and constraints on how they can be connected.

Admin

User

Fig:6.1Software architecture describes a system’s components and connectors.

Basic component types are

o Service users

o Service provider

Auxiliary component types are

o Enterprise service bus

o Directory service

SOA connector types are

External Metrics Module

Internal Metrics Module

System Metrics Module

Derived Metric Module

.NET

Framework

3.5

22

o Synchronous calls

o Asynchronous calls

The constraints that apply to the SOA architectural style are

a) service providers register their services in UDDI registry

b) service consumers can dynamically discover required services in a directory of

services

c) once a required service is found , the service consumer can bind the service into

its application

An ESB can mediate the interaction between service consumers and service Providers

Fig: 6.1.1: The “find-bind execute” paradigm.

Service Provider

The service provider is the service, the network-addressable entity that accepts

and executes requests from consumers. It can be a mainframe system, a component ,or

some other type of software system that executes the service request. The service

provider publishes its contract in the registry for access by service consumers.

Service Consumer

23

The service consumer is an application, service, or some other type of software

module that requires a service. It is the entity that initiates the locating of the service in

the registry, binding to the service over a transport, and executing the service function.

Service Registry

A service registry is a network-based directory that contains available services. Itis an

entity that accepts and stores contracts from service providers and provides those

contracts to interested service consumers.

Service Contract

A contract is a specification of the way a consumer of a service will interact with the

provider of the service. It specifies the format of the request and response from the

service. A service contract may require a set of preconditions and postconditions. The

preconditions and postconditions specify the state that the service must be in to execute a

particular function. The contract may also specify quality of service (QOS) levels. QOS

levels are specifications for the non functional aspects of the service. For instance, a

quality of service attribute is the amount of time it takes to execute a service method.

24

Fig: 6.1.2: The “Quality attribute metrics” paradigm

6.3 USER INTERFACE DESIGN

The goal of user interface design is to make the user's interaction as simple and

efficient as possible, in terms of accomplishing user goals what is often called user-

centered design. Good user interface design facilitates finishing the task at hand without

drawing unnecessary attention to it. Graphic design may be utilized to support its usability.

25

Fig: 5.3 user-interface design

26

CHAPTER 7

IMPLEMENTATION

7.1 IMPLEMENTATION DETAILS

The proposed model identifies metrics to evaluate design quality in the design

phase, giving organizations a chance to find and repair problems before they find their

way into the working system and save large amount of potential expenditure for problem

resolution. The proposed model is validated by its application to an information

management system to verify its correctness in deducing the correct set of metrics for

estimating the changes to system design.

7.1.1 Service Internal Metrics Module

The service internal metrics use service internal elements such as service name,

operations provided by the service, and characteristics of the messages defined in the

service. This module computes Number of operations, Numbers of Fine-grained

Parameter Operations, Number of Messages used, Number of Asynchronous operations,

Number of synchronous operations, Number of Inadequately Named operations in the

given services

“Number of operations” is used to measure complexity and is adapted from

“number of methods” metric in OO systems. Cohesion is a property which implies the

degree of relationships between operations defined in a service, and is measured by the

metric defined as “average used message factor.” This metric is inversely proportional to

the average number of messages in a service because smaller number of messages.

Since the fine-grained service is defined that the service which perform single

function, it is assumed that fine-grained parameter operations are operations which are

having single parameter. “Number of message “is calculated by addition of total number

of producer services and total number of consumer services.

27

Web Service operations can be either synchronous request-response or

asynchronous one-way. Synchronous request-response (the default behavior) means that

every time a client application invokes a Web Service operation, it receives a SOAP

response Asynchronous one-way means that the client never receives a SOAP response,

even a fault or exception.

When designing asynchronous one-way Web Service operations,

The backend component that implements the operation must explicitly return

void.

You cannot specify out or in-out parameters to the operation, you can only specify

in parameters.

So that the operation which have return type are assumed as “synchronous

operations”. and the operation which have return type as void are assumed as

“asynchronous operations”. All the constructors and destructors are assumed as

“Inadequately Named Operations”

7.1.2 Service External Metrics Module

The External metrics use information from services it is connected to. Metrics in

this group are used to measure the characteristics of consumer and producer services

either directly or indirectly connected to a given service.

This module computes Number of Consumers in same level, Number of directly

connected producer services, Number of directly connected consumer services, Total

number of provider services, total number of consumer services in the system.

The Service Composition Diagram is shown in figure 6.1. It shows connection

between different number of services in a file.

28

Figure 7.1: Service Composition Diagram

Number of Directed connected Consumer Services NDCS(A)= 2 (F&C)

Number of Directed connected Producer Services NDPS(A)= 2 (B&D)

Total number of Producer Services NTPS(A)= 5 (B,D ,E,F,C)

Total number of Consumer Services NTCS(A) =4 (F,C,H,G)

7.1.3 System Metrics Module

The last group, system metrics, measures the characteristics of the entire system

in general.

System metrics are

SM SSNS : System Size in Number of Services

SM NINS : Number of Inadequately Named Services

SM NINO : Number of Inadequately Named Operations

SM TMU : Total Number of Message Used

29

SM NAO : Number of Asynchronous Operations

SM NSO : Number of Synchronous Operations

SM NFPO : Number of Fine-Grained Parameter Operations

SM NPS : Number of Process Services

SM NIS : Number of Intermediary Services

SM NBS : Number of Basic Services

7.1.4 Derived Metrics Module

The fourth group of metrics make use of the three previously defined metrics

groups and are therefore referred to as derived metrics.

This module computes coupling, cohesion, complexity, design size, service

granularity, parameter granularity, consumability

Coupling(Average number of directly connected services(DM_ADCS)=

SEM_NDPS+SEM_NDCS/SM_SSNS

Cohesion(Inverse of Average number of Used Message(DM_IAUM)=

SM_SSNS/SM_TMU

Complexity(Number of Operations(DM_NO))=SM_NSO+SM_NAO*1.5

Design Size(Number of Services(NS))=SM_SSNS

Service Granularity(Squared Avg. Number of Operations to squared Avg. Number of

30

Messages(DM_AOMR)= SM_NAO+SM_NSO 2

SM_SSNS

SM_TMU 2

SM_SSNS

Parameter Granularity(Coarse-Grained parameter ratio(DM_CPR)=

(SM_NSO+SM_NAO-SM_NFPO)/(SM_NSO+SM_NAO)

7.1.5 Quality Attribute Factor Computation Module

This module computes the quality factors such as Effectiveness,

Understandability, Flexibility, Reusability, Discoverability

Effectiveness = 0.33 * Cohesion + 0.33 * Service Granularity + 0.33 * Parameter

Granularity

Understandability = -0.66 * Coupling + 0.25 * Cohesion -0.66 * Complexity -

0.66 * Design Size +0.25 * Service Granularity +

0.25 * Parameter Granularity + 0.25 * Consumability

Flexibility = -0.22 * Coupling + 0.61 * Service Granularity + 0.61 * Parameter

Granularity

Reusability = -0.5 * Coupling + 0.5 * Cohesion + 0.5 * Service Granularity + 0.5

* Consumability

Discoverability = 0.5 * Service Granularity + 0.5 * Parameter Granularity

31

CHAPTER 8

TESTING

8.1 INTRODUCTION

Testing is the process of executing a program or system with the intent of finding

errors. Or, it involves any activity aimed at evaluating an attribute or capability of a

program or system and determining that it meets its required results. Software is not unlike

other physical processes where inputs are received and outputs are produced. Where

software differs is in the manner in which it fails. Most physical systems fail in a fixed (and

reasonably small) set of ways. By contrast, software can fail in many bizarre ways.

Detecting all of the different failure modes for software is generally infeasible.

8.2 TEST PLAN

The first step in system testing process is to prepare a test plan that will test all

aspects of the system. A workable test plan was prepared in accordance with the design

specification. It includes output expected from the system criteria for evaluating outputs;

volumes of test data produce procedure for using test data.

The Test data should be such that they

Guarantee that all independent paths within a module have been exercised.

Exercise all logical decisions on their true or false sides.

Execute all Loops at their boundaries and with their operational boundary.

Exercise internal data structures to assure their validation.

8.3 UNIT TESTING

Testing of individual software components or modules. Typically done by the

programmer and not by testers, as it requires detailed knowledge of the internal program

design and code. May require developing test drive modules or test harnesses. Functional

and reliability testing in an Engineering environment. Producing tests for the behavior of

components of a product to ensure their correct behavior prior to system integration.

32

8.4 INTEGRATION TESTING

Testing in which modules are combined and tested as a group. Modules are

typically code modules, individual applications, client and server applications on a

network, etc. Integration Testing follows unit testing and precedes system testing. Testing

of integrated modules to verify combined functionality after integration. Modules are

typically code modules, individual applications, client and server applications on a

network, etc. This type of testing is especially relevant to client/server and distributed

systems. All the bottom or low-level modules, procedures or functions are integrated and

then tested. After the integration testing of lower level integrated modules, the next level of

modules will be formed and can be used for integration testing. This approach is helpful

only when all or most of the modules of the same development level are ready. This

method also helps to determine the levels of software developed and makes it easier to

report testing progress in the form of a percentage.

8.5 VALIDATION TESTING

Validation testing answers the question, "Are you building the right software

system". Another question, which the entire process of validation testing in software

engineering answers is, "Is the deliverable fit for purpose". Therefore, often the testing

activities are introduced early in the software development life cycle. The two major

areas, when validation testing should take place are in the early stages of software

development and towards the end, when the product is ready for release. In other words,

it is acceptance testing which is a part of validation testing.

Verification is intended to check that a product, service, or system (or portion

thereof, or set thereof) meets a set of initial design requirements, specifications, and

regulations. In the development phase, verification procedures involve performing special

tests to model or simulate a portion, or the entirety, of a product, service or system, then

performing a review or analysis of the modeling results. In the post-development phase,

verification procedures involve regularly repeating tests devised specifically to ensure

that the product, service, or system continues to meet the initial design requirements,

33

specifications, and regulations as time progresses. . Verification can be in development,

scale-up, or production. This is often an internal process.

Test Results: All the test cases mentioned above passed successfully. No defects

encountered.

34

CHAPTER 9

CONCLUSION

Android is a great platform for writing secure applications. It provides a type-safe

language (Java), an advanced security model, a proven class library, and a powerful set of

appropriate and securable abstractions for development on mobile devices. Android’s

framework typically defaults to safe behavior unless the developer explicitly decides to

share data between applications, and then it focuses the security model around the user.

Android’s open design means that finding and fixing transfer the data in one to another

devices that holes is done by the widest possible group of people.

35

CHAPTER 10

FUTURE ENHANCEMENT

Future enhancements are one of the inevitable for any kind of software

project. The important thing is that the system should be flexible enough, for further

modifications. Considering this factor, the system is designed in such a way that the

provision is given for further enhancement, without affecting the system presently

developed. Some of the enhancement feature’s that can be applicable for our project in

future are listed as follows.

To reduce the time efficiency.

To implement all the mobile with different platform.

To improve the security.

36

BIBLIOGRAPHY

BOOKS

[1] Andreas Stolcke, , Barry Chen, Horacio Franco,Venkata Ramana Rao

Gadde, Martin Graciarena, , Mei-Yuh Hwang, Katrin Kirchhoff, , Arindam

Mandal, Nelson Morgan, , Xin Lei, Tim Ng, Mari Ostendorf, Kemal Sönmez,

Anand Venkataraman, Dimitra Vergyri, and Qifeng Zhu, “Recent Innovations in

Speech-to-Text Transcription at Sri- icsi-uw” IEEE Transactions On Audio,

Speech, And Language Processing,vol.14,no. 5, septembe 2006,pp 1729-1744

[2] Brandon Ballinger, Cyril Allauzen, Alexander Gruenstein, Johan

Schalkwyk, “On-Demand Language Model Interpolation for Mobile Speech

Input”, INTERSPEECH 2010, 26-30 September 2010, Makuhari, Chiba, Japan, pp 1812-1815

[3] Ryuichi Nisimura, Jumpei Miyake, Hideki Kawahara and Toshio Irino,

“Speech-To-Text Input Method For Web System Using Javascript”, IEEE SLT

2008 pp 209-212

[4] M. Tomalin, F. Diehl, M.J.F. Gales, J. Park & P.C. Woodland , “Recent

Improvements To The Cambridge Arabic Speech-To-Text Systems”, ICASSP 2010 pp 4382-4385

[5] Janet See, Umi Kalsom Yusof, Amin Kianpisheh,“User Acceptance

towards a Personalised Handsfree Messaging Application (iSay-SMS)”,

CSSR 2010 Initial Submission December 5-7,2010 pp 1165-

1170

WEBSITES

http://developer.android.com

http://developer.android.com/reference/android/bluetooth/package summary.html

http://developer.android.com/sdk/index.html

http://developer.android.com/sdk/installing/bundle.html

http://en.wikipedia.org/wiki/Eclipse_(software)

37

APPENDIX A

SCREEN SHOTS

A[1] : SMS Application Installed in Android Mobile

38

A[2] : SMS Application Inbox View

39

A[3] : SMS Application Input Type Selection

40

A[4] : SMS Application Keypad Type

41

A[5] : SMS Application Voice Recognition Type

42

A[6] : SMS Application Contact List

43

A[7] : SMS Application Sample Keypad Message

44

A[8] : SMS Application Message View Status

45

A[9] : SMS Application Message Opened Status

46

APPENDIX B

CODING

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:tools="http://schemas.android.com/tools"

android:layout_width="match_parent"

android:layout_height="match_parent"

android:paddingBottom="@dimen/activity_vertical_margin"

android:paddingLeft="@dimen/activity_horizontal_margin"

android:paddingRight="@dimen/activity_horizontal_margin"

android:paddingTop="@dimen/activity_vertical_margin"

tools:context=".MainActivity" >

<TextView

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="@string/hello_world" />

</RelativeLayout>

47

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"



android:orientation="vertical" >

<TextView

android:id="@+id/textViewSMSSender"

android:paddingLeft="2dp"

android:textSize="20dp"

android:textStyle="bold"

android:textColor="#0000FF"



android:text="TextView" />

<TextView

android:id="@+id/textViewMessageBody"

android:paddingLeft="5dp"

android:textColor="#ffffff"

android:textSize="17dp"

android:maxLines="1"



android:text="TextView" />

</LinearLayout>

48


<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

android:layout_width="fill_parent"

android:layout_height="fill_parent"

android:gravity="right"

android:orientation="vertical"

>

<ListView

android:id="@+id/listView1"


android:layout_height="350dp" >

</ListView>

<FrameLayout


android:layout_height="60dp"

android:background="@android:color/background_light" >

<ImageButton

android:id="@+id/imageButton1"

android:layout_width="60dp"


android:src="@drawable/msg" />

<TextView

android:id="@+id/textView1"



android:layout_gravity="center|center_horizontal|right"

android:text="Compose Message"

android:textAppearance="?android:attr/textAppearanceLarge"

android:textColor="#000000" />

</FrameLayout>

</LinearLayout>

49




android:layout_height="match_parent" >

<FrameLayout

android:id="@+id/frameLayout1"



android:background="@android:color/darker_gray" >

<TextView

android:id="@+id/textView1"



android:layout_gravity="center_horizontal"

android:text="Select Input Type"

android:textAppearance="?android:attr/textAppearanceLarge" />

</FrameLayout>

<ImageButton




android:layout_below="@+id/frameLayout1"

android:layout_centerHorizontal="true"

android:layout_marginTop="48dp"

android:src="@drawable/mic" />

<ImageButton




android:layout_alignParentBottom="true"

android:layout_centerHorizontal="true"

android:layout_marginBottom="24dp"

android:src="@drawable/key" />

</RelativeLayout>

50




android:layout_height="match_parent" >

<FrameLayout




android:layout_alignParentLeft="true"

android:layout_alignParentRight="true"


<Button

android:id="@+id/buttonno"



android:layout_gravity="right"

android:background="@drawable/mic"

android:minWidth="46dip"

android:text="..." />

<EditText

android:id="@+id/editTextFileName"



android:layout_alignTop="@id/buttonno"

android:layout_toLeftOf="@id/buttonno"

android:ems="10"

android:hint="Receiver Number"

android:inputType="textUri" />

</FrameLayout>

<FrameLayout







<EditText

android:id="@+id/editText1"



android:ems="10"

51

android:gravity="top"

android:hint="Message" >

<requestFocus />

</EditText>

<Button

android:id="@+id/buttonmsg"



android:layout_gravity="center|center_horizontal|left"

android:background="@drawable/mic"



<Button

android:id="@+id/button1"



android:layout_gravity="center|right"

android:text="Send" />

</FrameLayout>

</RelativeLayout>

52





android:layout_gravity="bottom" >

<FrameLayout





android:layout_alignParentRight="true"


<Button

android:id="@+id/buttonFileSelect"



android:layout_gravity="right"

android:background="@drawable/landline"



<EditText

android:id="@+id/editTextFileName"



android:layout_alignTop="@id/buttonFileSelect"

android:layout_toLeftOf="@id/buttonFileSelect"

android:ems="10"

android:hint="Receiver Number"

android:inputType="textUri" />

</FrameLayout>

<FrameLayout







<EditText

android:id="@+id/editText1"


53


android:ems="10"

android:gravity="top"

android:hint="Message" >

<requestFocus />

</EditText>

<Button

android:id="@+id/button1"



android:layout_gravity="center|right"

android:text="Send" />

</FrameLayout>

</RelativeLayout>

54

package net.learn2develop.SMS;

import android.R.integer;

import android.app.Activity;

import android.app.AlertDialog;

import android.app.PendingIntent;

import android.content.BroadcastReceiver;

import android.content.ContentValues;

import android.content.Context;

import android.content.DialogInterface;

import android.content.Intent;

import android.content.IntentFilter;

import android.database.Cursor;

import android.net.Uri;

import android.os.Bundle;

import android.telephony.SmsManager;

import android.util.SparseBooleanArray;

import android.view.KeyEvent;

import android.view.View;

import android.view.View.OnClickListener;

import android.view.View.OnKeyListener;

import android.widget.AdapterView;

import android.widget.AdapterView.OnItemClickListener;

import android.widget.Button;

import android.widget.EditText;

import android.widget.ImageButton;

import android.widget.ListView;

import android.widget.SimpleCursorAdapter;

import android.widget.TextView;

import android.widget.Toast;

public class MainActivity extends Activity {

ImageButton btnSendSMS;

IntentFilter intentFilter;

EditText msg,no;

String phoneNo,sms,item;

private BroadcastReceiver intentReceiver = new BroadcastReceiver() {

@Override

public void onReceive(Context context, Intent intent) {

//---display the SMS received in the TextView---

55

//TextView SMSes = (TextView) findViewById(R.id.textView1);

// SMSes.setText(intent.getExtras().getString("sms"));

}

};

/** Called when the activity is first created. */

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

btnSendSMS=(ImageButton)findViewById(R.id.imageButton1);

btnSendSMS.setOnClickListener(new OnClickListener() {

@Override

public void onClick(View v) {

// TODO Auto-generated method stub

Intent intent1 = new Intent(MainActivity.this,second.class);

startActivity(intent1);

//finish();

}

});

//---intent to filter for SMS messages received---

intentFilter = new IntentFilter();

intentFilter.addAction("SMS_RECEIVED_ACTION");

//---register the receiver---

registerReceiver(intentReceiver, intentFilter);

/* if (phoneNo.length()>0 && sms.length()>0)

{

btnSendSMS.setVisibility(View.VISIBLE);

}*/

final ListView lViewSMS = (ListView) findViewById(R.id.listView1);

int[] arrayViewIDs = new

int[]{R.id.textViewSMSSender,R.id.textViewMessageBody};

56

String[] arrayColumns = new String[]{"address","body"};

Cursor cursor;

cursor = getContentResolver().query(Uri.parse("content://sms/inbox"), null, "read =

0", null, null);

// cursor = getContentResolver().query(Uri.parse("content://sms/inbox"), null, null,

null, "date desc limit 1");

/* getContentResolver().query(SMS_INBOX, new String[] {body, address},

null, null, "date desc limit 3");*/

// create an Adapter with arguments layoutID, Cursor, Array Of Columns, and Array of

ViewIds which is to be Populated

SimpleCursorAdapter adapter = new SimpleCursorAdapter(MainActivity.this,

R.layout.list, cursor, arrayColumns, arrayViewIDs);

lViewSMS.setAdapter(adapter);

lViewSMS.setOnItemClickListener(new OnItemClickListener() {

@Override

public void onItemClick(AdapterView<?> arg0, View arg1, int arg2,

long arg3) {


/*if(arg0.getItemAtPosition(arg2).toString() != null)

{*/

// ContentValues values = new ContentValues();

//values.put("status", SmsManager.STATUS_ON_ICC_READ);

final TextView

textViewSMSSender=(TextView)findViewById(R.id.textViewSMSSender);

TextView

textViewSMSBody=(TextView)findViewById(R.id.textViewMessageBody);

String smsBody;

smsBody=textViewSMSBody.getText().toString();

int s1;

s1=smsBody.length();

String smsSender=textViewSMSSender.getText().toString();

String ss=smsBody.substring(0, 7);

SmsManager manager = SmsManager.getDefault();

manager.sendTextMessage(smsSender, null, ss+",This Message Is Viewed By

the User!", null, null);

57

if(s1<=2)

{

/* String ss=smsBody.substring(0, 1);

Toast.makeText(MainActivity.this, ss, 10).show();



the User!", null, null);*/

}

if(s1>=20)

{

/* String ss=smsBody.substring(0, 20);




the User!", null, null);*/

}

/*if(s1<=s2)

{




}

else

{

String s=smsBody.substring(0, 20);


manager.sendTextMessage(smsSender, null, s+",This Message Is Viewed By


}

*/

// Toast.makeText(MainActivity.this, smsSender, 10).show();

// int ss= lViewSMS.getSelectedItemPosition();

/* String ss= (String) lViewSMS.getItemAtPosition(arg2);


lViewSMS.get;*/

58

/* Intent i = new Intent(android.content.Intent.ACTION_VIEW);

i.putExtra("address", smsSender);

i.putExtra("sms_body", "Your Message Has Viewed!");

i.setType("vnd.android-dir/mms-sms");

startActivity(i);*/

String smsBodyy=textViewSMSBody.getText().toString();

AlertDialog dialog = new AlertDialog.Builder(MainActivity.this).create();

dialog.setTitle("SMS From : "+smsSender);

dialog.setIcon(android.R.drawable.ic_dialog_info);

dialog.setMessage(smsBodyy);

dialog.setButton(DialogInterface.BUTTON_POSITIVE, "OK",

new DialogInterface.OnClickListener() {

public void onClick(DialogInterface dialog, int which)

{

dialog.dismiss();

return;

}

});

dialog.show();

}

/*}*/

});

/* final ArrayList<String> sms = new ArrayList<String>();

ContentResolver cr = getContentResolver();

final Cursor cursor = cr.query(Uri.parse("content://sms/inbox"), new String []

{"person","address","body","date","_id","read", "status", "type", "reply_path_present",

"subject","thread_id"} , null, null,"date DESC");

final int indexBody = cursor.getColumnIndex("body");

final int indexAddr = cursor.getColumnIndex("address");

if (indexBody < 0 || !cursor.moveToFirst())

return ;

sms.clear();

do {

String str = "Sender : " + cursor.getString(1) + "\n"

+ cursor.getString(indexBody);

sms.add(str);

59

// ADDRESS[total] = cursor.getString(indexAddr);

// total++;

} while (cursor.moveToNext());

final ListView lViewSMS = (ListView) findViewById(R.id.listView1);

lViewSMS.setAdapter(new ArrayAdapter<String>(this,

android.R.layout.simple_list_item_1, sms));

lViewSMS.setOnItemClickListener(new OnItemClickListener() {

@Override

public void onItemClick(AdapterView<?> arg0, View arg1, int

arg2,

long arg3) {


String s=arg0.getItemAtPosition(arg2).toString();

if(arg0.getItemAtPosition(arg2).toString() != null)

{

Toast.makeText(MainActivity.this,s , 10).show();

}

//Toast.makeText(MainActivity.this,indexAddr ,

10).show();

}

});*/

}

@Override

protected void onResume() {

//---register the receiver---

//registerReceiver(intentReceiver, intentFilter);

super.onResume();

}

@Override

protected void onPause() {

//---unregister the receiver---

//unregisterReceiver(intentReceiver);

super.onPause();

}

@Override

protected void onDestroy() {

60

//---unregister the receiver---

unregisterReceiver(intentReceiver);

super.onPause();

}

/*

//---sends an SMS message to another device---

private void sendSMS(String phoneNumber, String message)

{

SmsManager sms = SmsManager.getDefault();

sms.sendTextMessage(phoneNumber, null, message, null, null);

}

*/

//---sends an SMS message to another device---

}

61







import android.widget.ImageButton;

public class second extends Activity{

ImageButton imageButton1,imageButton2;



setContentView(R.layout.second);

imageButton1=(ImageButton)findViewById(R.id.imageButton1);

imageButton1.setOnClickListener(new OnClickListener() {

@Override



Intent intent1 = new

Intent(second.this,speak.class);


}

});

imageButton2=(ImageButton)findViewById(R.id.imageButton2);

imageButton2.setOnClickListener(new OnClickListener() {

@Override



Intent intent1 = new Intent(second.this,test.class);


}

});

}

}

62






import android.telephony.SmsMessage;


public class SMSReceiver extends BroadcastReceiver

{

@Override

public void onReceive(Context context, Intent intent)

{

//---get the SMS message passed in---

Bundle bundle = intent.getExtras();

SmsMessage[] msgs = null;

String str = "";

if (bundle != null)

{

//---retrieve the SMS message received---

Object[] pdus = (Object[]) bundle.get("pdus");

msgs = new SmsMessage[pdus.length];

for (int i=0; i<msgs.length; i++){

msgs[i] = SmsMessage.createFromPdu((byte[])pdus[i]);

str += "SMS from " + msgs[i].getOriginatingAddress();

str += " :";

str += msgs[i].getMessageBody().toString();

str += "\n";

}

//---display the new SMS message---

Toast.makeText(context, str, Toast.LENGTH_SHORT).show();

//---launch the MainActivity---

Intent mainActivityIntent = new Intent(context, MainActivity.class);

mainActivityIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

context.startActivity(mainActivityIntent);

//---send a broadcast to update the SMS received in the activity---

Intent broadcastIntent = new Intent();

broadcastIntent.setAction("SMS_RECEIVED_ACTION");

broadcastIntent.putExtra("sms", str);

context.sendBroadcast(broadcastIntent);

}

}

}

63


import java.util.ArrayList;



import android.content.ActivityNotFoundException;








import android.provider.ContactsContract;

import android.provider.ContactsContract.CommonDataKinds.Phone;

import android.speech.RecognizerIntent;


import android.text.InputFilter;






public class speak extends Activity {

protected static final int RESULT_SPEECH = 1,RESULT_SPEECH1=0;

public Button b,b1,buttonmsg;

EditText msg;

String phoneNo,sms;

public EditText editTextFileName,editText1;

private BroadcastReceiver intentReceiver = new BroadcastReceiver(){

@Override



}

};



setContentView(R.layout.speak);

b1=(Button)findViewById(R.id.button1);

buttonmsg =(Button)findViewById(R.id.buttonmsg);

buttonmsg.setVisibility(View.VISIBLE);

editText1=(EditText)findViewById(R.id.editText1);

editTextFileName=(EditText)findViewById(R.id.editTextFileName) ;

msg = (EditText) findViewById(R.id.editText1);

/* int m=160;

msg.setFilters(new InputFilter[] {new InputFilter.LengthFilter(m)});

64

int maxLength = 10;

editTextFileName.setFilters(new InputFilter[] {new

InputFilter.LengthFilter(maxLength)});

*/

buttonmsg.setOnClickListener(new View.OnClickListener() {

@Override


buttonmsg.setVisibility(View.GONE);

Intent intent = new Intent(

RecognizerIntent.ACTION_RECOGNIZE_SPEECH);

intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, "en-US");

try {

startActivityForResult(intent,

RESULT_SPEECH1);

editText1.setText("");

} catch (ActivityNotFoundException a) {

Toast t =

Toast.makeText(getApplicationContext(),

"Ops! Your device doesn't

support Speech to Text",

Toast.LENGTH_SHORT);

t.show();

}

}

});

b=(Button)findViewById(R.id.buttonno);

b.setOnClickListener(new View.OnClickListener() {

@Override


Intent intent = new Intent(

RecognizerIntent.ACTION_RECOGNIZE_SPEECH);

intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, "en-US");

try {

startActivityForResult(intent,

RESULT_SPEECH);

editTextFileName.setText("");

} catch (ActivityNotFoundException a) {

Toast t =

Toast.makeText(getApplicationContext(),

65

"Ops! Your device doesn't

support Speech to Text",

Toast.LENGTH_SHORT);

t.show();

}

}

});

b1.setOnClickListener(new OnClickListener() {

@Override



phoneNo = editTextFileName.getText().toString();

sms = msg.getText().toString();

if(phoneNo.equals(""))

{

Toast.makeText(getBaseContext(),

"Please enter phone number.",

Toast.LENGTH_SHORT).show();

}

else {

//Toast.makeText(getApplicationContext(), phoneNo, 10).show();

sendSMS(phoneNo, sms);

msg.setText("");


buttonmsg.setVisibility(View.VISIBLE);

}

}

private void sendSMS(String phoneNumber, String message)

{


String SENT = "SMS_SENT";

String DELIVERED = "SMS Received";

PendingIntent sentPI = PendingIntent.getBroadcast(speak.this, 0,

new Intent(SENT),0 );

// PendingIntent sentPI = PendingIntent.getBroadcast(this, 0,

// new Intent(SENT), 0);

PendingIntent deliveredPI =

PendingIntent.getBroadcast(speak.this, 0,

new Intent(DELIVERED), 0);

//---when the SMS has been sent---

registerReceiver(new BroadcastReceiver(){

@Override

public void onReceive(Context arg0, Intent arg1) {

switch (getResultCode())

{

case Activity.RESULT_OK:

66

Toast.makeText(getBaseContext(), "SMS sent",


break;

case SmsManager.RESULT_ERROR_GENERIC_FAILURE:

Toast.makeText(getBaseContext(), "Generic failure",


break;

case SmsManager.RESULT_ERROR_NO_SERVICE:

Toast.makeText(getBaseContext(), "No service",


break;

case SmsManager.RESULT_ERROR_NULL_PDU:

Toast.makeText(getBaseContext(), "Null PDU",


break;

case SmsManager.RESULT_ERROR_RADIO_OFF:

Toast.makeText(getBaseContext(), "Radio off",


break;

}

}

}, new IntentFilter(SENT));

//---when the SMS has been delivered---


@Override



{


Toast.makeText(getBaseContext(), "SMS Received By

"+phoneNo,


break;

case Activity.RESULT_CANCELED:

Toast.makeText(getBaseContext(), "SMS not delivered",


break;

case Activity.RESULT_FIRST_USER:

Toast.makeText(getBaseContext(), "Ur SMS is

Viewed ",


}

}

}, new IntentFilter(DELIVERED));

SmsManager sms1 = SmsManager.getDefault();

sms1.sendTextMessage(phoneNumber, null, message, sentPI,

deliveredPI);

// Toast.makeText(getApplicationContext(), phoneNumber,

10).show();

// sms1.sendTextMessage("5556", null, message, sentPI,

deliveredPI);

}

67

});

}

@Override

protected void onActivityResult(int requestCode, int resultCode, Intent data) {


super.onActivityResult(requestCode, resultCode, data);

switch (requestCode) {

case RESULT_SPEECH1: {

if (resultCode == RESULT_OK && null != data) {

ArrayList<String> text = data

.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);

editText1.setText(text.get(0));

}

break;

}

case RESULT_SPEECH: {

if (resultCode == RESULT_OK && null != data) {

ArrayList<String> text = data

.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);

editTextFileName.setText(text.get(0));

}

break;

}

}

}

}

68





import android.content.ContentResolver;







import android.provider.Contacts.People;

import android.provider.ContactsContract;

import android.provider.ContactsContract.CommonDataKinds.Phone;

import android.provider.ContactsContract.Contacts;


import android.text.InputFilter;






public class test extends Activity {

public Button b,b1;

EditText msg;

String phoneNo,sms;

public EditText editTextFileName;

private BroadcastReceiver intentReceiver = new BroadcastReceiver(){

@Override



}

};



setContentView(R.layout.ss);

b1=(Button)findViewById(R.id.button1);

69

editTextFileName=(EditText)findViewById(R.id.editTextFileName) ;

msg = (EditText) findViewById(R.id.editText1);

int m=160;

msg.setFilters(new InputFilter[] {new InputFilter.LengthFilter(m)});

int maxLength = 10;



b=(Button)findViewById(R.id.buttonFileSelect);

b.setOnClickListener(new OnClickListener() {

@Override



int maxLength = 14;



if(v==b){

Intent intent = new

Intent(Intent.ACTION_GET_CONTENT);

intent.setType(ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_T

YPE);

startActivityForResult(intent, 1);

/*Intent i =new

Intent(Intent.ACTION_PICK,Contacts.CONTENT_URI);

startActivityForResult(i, 1);*/

}

}

});

b1.setOnClickListener(new OnClickListener() {

@Override



phoneNo = editTextFileName.getText().toString();

sms = msg.getText().toString();

if(phoneNo.equals(""))

{

Toast.makeText(getBaseContext(),

"Please enter phone number.",


}

70

else {

//Toast.makeText(getApplicationContext(), phoneNo,

10).show();

sendSMS(phoneNo, sms);

msg.setText("");


}

}

private void sendSMS(String phoneNumber, String

message) {


String SENT = "SMS_SENT";

String DELIVERED = "SMS Received";

PendingIntent sentPI = PendingIntent.getBroadcast(test.this,

0, new Intent(SENT),0 );

// PendingIntent sentPI = PendingIntent.getBroadcast(this, 0,

// new Intent(SENT), 0);

PendingIntent deliveredPI =

PendingIntent.getBroadcast(test.this, 0,

new Intent(DELIVERED), 0);

//---when the SMS has been sent---


@Override



{


Toast.makeText(getBaseContext(), "SMS sent",


break;

case SmsManager.RESULT_ERROR_GENERIC_FAILURE:

Toast.makeText(getBaseContext(), "Generic

failure",


break;

case SmsManager.RESULT_ERROR_NO_SERVICE:

Toast.makeText(getBaseContext(), "No service",


71

break;

case SmsManager.RESULT_ERROR_NULL_PDU:

Toast.makeText(getBaseContext(), "Null PDU",


break;

case SmsManager.RESULT_ERROR_RADIO_OFF:

Toast.makeText(getBaseContext(), "Radio off",


break;

}

}

}, new IntentFilter(SENT));

//---when the SMS has been delivered---


@Override



{


Toast.makeText(getBaseContext(), "SMS Received

By "+phoneNo,


break;

case Activity.RESULT_CANCELED:

Toast.makeText(getBaseContext(), "SMS not

delivered",


break;

case Activity.RESULT_FIRST_USER:

Toast.makeText(getBaseContext(), "Ur SMS is

Viewed ",


}

}

}, new IntentFilter(DELIVERED));

SmsManager sms1 = SmsManager.getDefault();

sms1.sendTextMessage(phoneNumber, null, message, sentPI,

deliveredPI);

// Toast.makeText(getApplicationContext(), phoneNumber,

10).show();

// sms1.sendTextMessage("5556", null, message, sentPI,

deliveredPI);

}

72

});

}

@Override

protected void onActivityResult(int requestCode, int resultCode, Intent data) {


super.onActivityResult(requestCode, resultCode, data);

if(requestCode == 1){

Uri contactData = data.getData();

Cursor cursor = managedQuery(contactData, null, null, null, null);

cursor.moveToFirst();

// String name =

cursor.getString(cursor.getColumnIndexOrThrow(Contacts.DISPLAY_NAME));

String number =

cursor.getString(cursor.getColumnIndex(Phone.NUMBER));

//String email =

cursor.getString(cursor.getColumnIndexOrThrow(People.PRIMARY_EMAIL_ID));

// contactName.setText(name);

// contactNumber.setText(number);

// contactEmail.setText(email);

editTextFileName.setText(number);

}

}

}

73

APPENDIX C

TECHNOLOGY/SOFTWARE

Android Development Kit

Android software development is the process by which new applications are

created for the Android operating system. Applications are usually developed in the Java

programming language using the Android Software Development Kit, but other

development tools are available. As of October 2012, more than 700,000 applications

have been developed for Android, with over 25 billion downloads.[ A June 2011 research

indicated that over 67% of mobile developers used the platform, at the time of

publication. In Q2 2012; around 105 million units of Android smartphones were shipped

which acquires a total share of 68% in overall smartphones sale till Q2 2012.

Android SDK

The Android software development kit (SDK) includes a comprehensive set of

development tools.These include adebugger, libraries, a handset emulator based

on QEMU, documentation, sample code, and tutorials. Currently supported development

platforms include computers running Linux(any modern desktop Linux distribution), Mac

OS X 10.5.8 or later,Windows XPor later. The officially supported integrated

development environment (IDE) is Eclipse using the Android Development Tools (ADT)

Plugin, though IntelliJ IDEA IDE (all editions) fully supports Android development out

of the box, and NetBeans IDE also supports Android development via a

plugin. Additionally, developers may use any text editor to edit Java and XML files, then

use command line tools (Java Development Kit and Apache Ant are required) to create,

build and debug Android applications as well as control attached Android devices (e.g.,

triggering a reboot, installing software package(s) remotely).

Enhancements to Android's SDK go hand in hand with the overall Android

platform development. The SDK also supports older versions of the Android platform in

case developers wish to target their applications at older devices. Development tools are

74

downloadable components, so after one has downloaded the latest version and platform,

older platforms and tools can also be downloaded for compatibility testing.

Android applications are packaged in .apk format and stored under /data/app folder on the

Android OS (the folder is accessible only to the root user for security reasons). APK

package contains .dex files (compiled byte code files called Dalvik executables), resource

files, etc.

Android Debug Bridge

The Android Debug Bridge (ADB) is a toolkit included in the Android SDK

package. It consists of both client and server-side programs that communicate with one

another. The ADB is typically accessed through the command-line interface.

The format for issuing commands through the ADB is typically:

adb [-d|-e|-s <serialNumber>] <command>

In a security issue reported in March 2011, ADB was targeted as a vector to attempt to

install a rootkit on connected phones using a "resource exhaustion attack".

75

APPENDIX D

LIST OF FIGURES

S.No FIGURE NO NAME PAGE NO

1 4.1 Overall Usecase diagram 16

2 4.2 Usecase diagram for internal metric module 17

3 4.3 Usecase diagram for external metric module 18

4 4.4 Usecase diagram for system metric module 19

5 4.5 Usecase diagram for derived metric module 20

6 4.6 Overall Sequence diagram of the system 21

7 4.7 Overall Activity diagram of the system 22

8 5.1 Architectural diagram 24

9 5.1.1 The”find-bind execute” paradigm 25

10 5.1.2 The “quality attribute metric” paradigm 26

11 5.2 Data Design diagram 27

12 5.3 User interface diagram 36

13 6.1 Service Component Diagram 39

76

APPENDIX E

DEFINITION AND ABBREVIATIONS

S.No TERMS Definition/Abbreviations

1. ADK Android Development kit

2. IDE Integrated development environment

3. SDLC Software Development Life Cycle

4. UML Unified Modeling Language

5. ER Entity Relationship diagram

6. SDK Software Development Kit

status representation for message using android application

Documents

sms status

sms user

unread sms

incoming sms

particular sms substring

text systems

message status

faster sms technology