WELCOME TO

CLIENT PROVISIONING
Presented by
Mastan Vali.N.C

 AIM OF THE PROJECT

It is an enterprise world application that
allows to do online banking transactions
between different types of clients like
cellphones,webclients and others.
Users can directly do banking transactions
such as depositing,withdrawing,and other
transactions with the help of mobile
devices.
There are three modules present in this
project:
Client Module

ABOUT THE SOFTWARE

SELECTED
The different applications
used in this project are:
MIDLETS
J2EE(EJB)
J2ME
SERVLETS

Why Java is selected?

Java is an object oriented, multi thread
programming language developed by Sun
Microsystems in 1991 .
Java was designed to meet all the real world
requirements with its key features, which are:
Simple and Powerful
Portable
Object Oriented
Multithreaded

Introduction to java

java introduced developer friendly packages like

Swing, AWT, Servlets, EJBs, JSPs to augment its
power to easily develop web applications.
These technologies have fared well and propelled
java as the most suitable and reliable language to
create web enabled high-end applications.
Web services enable diverse applications to talk to
and interoperate with each other. The increasing
demand for mobile applications is opening a new
era in distributed computing.

PROJECT OVERVIEW

WHAT IS
PROVISIONING?
The Client Provisioning Specification,
provides a framework and APIs for making
applications available on a J2EE server.
Provisioning servers are often compared to
vending machines
Like cans of soda in a vending machine,
client application bundles are packaged for
immediate delivery and consumption.

 The provisioning specification allows the server

to offer software based on what the client can
support.
The server keeps a list of supported platforms
and their capabilities.
These capabilities can be anything from screen
size and bit depth to supported network
protocols and APIs.

 If users download only JAR files, a web server

alone will probably suffice, but if your need is to
offer applications to large numbers of users on
many different devices, J2EE with clientprovisioning support is a better alternative.
Many mobile devices can use browser-based
applications, and these can be updated without
touching the client because the browser doesn't
store the application locally.

 Applications deployed on the client can offer a

richer set of features to both developer and end
user, and have the added benefit of being useful
even when not connected to the network, but
updates are more difficult because there are so
many different client platforms.
A centrally managed repository of content and
applications solves the problem of deploying to a
wide variety of platforms.
JSR 124 is the architecture for such a repository.

JSR
JSR is not specific to any single client technology,
it is particularly useful to J2ME developers
deploying Mobile Device Information Profile
(MIDP) applications.
The specification doesn't limit or specify the client
platform, but for the first release the focus has
been on client devices supporting MIDP, and on
desktop clients deployed using the Java Network
Launching Protocol (JNLP), which is used
primarily by Java Web Start.

 The three packages proposed for the final release

Package Name
Description
of the JSR
are :
javax.provisioning

Base set of interfaces and classes representing devices, bundles, and other
deliverables.
All the APIs needed to write a provisioning application.

javax.provisioning.ad
apter

Interfaces for defining provisioning adapters.

All the APIs needed to extend the provisioning server to provision a new device.

javax.provisioning.ma
tcher

Interfaces and classes for customizing and extending the capability-matching

engine.
All the APIs needed to alter the basic matching policies in the repository (for
advanced developers)

 The provisioning application relies on three

configuration files:
devices.xml and adapters.xml
provide information about supported
devices and adapters, and
matchers.xml configures customized
provisioning matchers

CLIENT
PROVISIONING

The client provisioning specification:

is an attempt to provide plug and play
applications especially for mobile and small
devices.
This specification defines the rules to allow
application servers conforming to the J2EE
specification to host client services and
applications that can be delivered to micro and
mobile devices.
The way this can be accomplished is with the aid
of a provisioning server that would allow client
devices to discover services advertised on the
server.

 The chosen service can then be delivered to the

device based on parameters like application type,
client type, subscription status, etc.
The service could be in the form of java
bytecodes or jar files that would be downloaded
on to the client machine and run on the client.
The target device could be any J2EE compliant
device capable of handling J2EE applications

ARCHITECTURE:
The client provisioning specification is designed
to function as a non-intruding part of any J2EE
compliant server.
A provisioning server handles any request from
client devices.
When a request is received the provisioning server
would check with the repository of applications
registered with it and provide access to the
application if it is available.
Though java can handle multiple platforms,
provisioning applications may have to cater to
different protocols on different platforms.

 A Mobile device may need data in XML

format, while a JNLP application may need
a JNLP file to process a request.
The provisioning server would need to
cater to the needs of all these kinds of
requests and protocols.
To alleviate this problem the specification
defines a provisioning adapter.

 A provisioning adapter defines the

provisioning protocol required to
provisioning on particular client platform.
The provisioning API provides a
client/device independent API that uses the
provisioning adapters to provide support for
multiple platforms and protocols

PROVISIONING PROCESS
The provisioning process can be broken down into
three tasks:
Stocking: managing the repository;
adding and removing client application
bundles
Discovery: finding out what bundles are
available for delivery from the
provisioning server
Delivery: delivering the application
bundle to the client

J2EE
J2EE provides business services to different
clients.
J2EE architecture is n-tier.Here all clients
are considered as one-tier and different
servers are considered different tiers.
It separates the middleware logic from
business logic.
J2EE provides two types of components:
Web components(servlets,JSP)
Business components(EJB)

ENTERPRISE JAVA BEANS

 EJB is a component based architecture that

simplifies the process of design and creates
distributed components in multi tier
environment.
As EJB is used in the current project ,EJB
components doesnot receive the client
requests directly that are given by different
sorts of clients.But are received by servlets
which act as clients to EJB.

 EJB is used as solution due to following reasons:

As component designed can have more than one
business method.
To provide flexible mechanism to our clients to
fire business methods they want directly.
To gain middleware services from application
server.
To process the banking data in simple,safe,secure
and scalable ways.
To provide solution to real world enterprise
business values.

Benefits of Enterprise Beans

enterprise beans simplify the development of large,
distributed applications.
EJB container provides system-level services to
enterprise beans, the bean developer can concentrate
on solving business problems.
enterprise beans are portable components, the
application assembler
can build new applications from existing beans.
These applications can run on any compliant J2EE
server.

When to Use Enterprise Beans

Requirements:
To accommodate a growing number of
users, you may need to distribute an
applications components across multiple
machines. Not only can the enterprise beans
of an application run on different machines,
but their location will remain transparent to
the clients

If transactions are required to ensure data

integrity,Enterprise beans support transactions.
This mechanism manages the concurrent access
of shared objects.
If the application has a variety of clients,then
with just a few lines of code,remote clients can
easily locate enterprise beans.

Types of Enterprise Beans

The three different types of enterprise
beans:
Session Beans
Entity Beans
Message Driven Beans

What Is a Session Bean?

A session bean represents a single client inside the
J2EE server. To access an application that is
deployed on the server, the client invokes the
session beans methods.
a session bean is similar to an interactive session
Session Performs a task for a client
a session bean is not persistent i.e., its data is not
saved to a database. When the client terminates, its
session bean appears to terminate and is no longer
associated with the client.

State Management Modes

Two types of session beans:
Stateless session beans:A stateless session
bean does not maintain a conversational
state for a particular client.
Statefull session beans:A statefull session
bean maintains a conversational state for a
particular client.

Stateful Session Beans

In a statefulsession bean, the instance variables

represent the state of a unique client-bean session.
The state of an object consists of the values of its
instance variables. The state is retained for the
duration of the client-bean session.
If the client removes the bean or terminates, the
session ends and the state disappears. when the
conversation between the client and the bean ends
there is no need to retain the state.

Stateless Session Beans

A stateless session bean does not maintain a
conversational state for a particular client.
When a client invokes the method of a stateless
bean, the beans instance variables may contain a
state, but only for the duration of the invocation.
When the method is finished, the state is no longer
retained.
Except during method invocation, all instances of
a stateless bean are equivalent, allowing the EJB
container to assign an instance to any client.

When to Use Session Beans

At any given time, only one client has
access to the bean instance.
When the state of the bean is not persistent,
exists only for a short period of time,session
beans are used.

 The bean needs to hold information about

the client across method invocations.
The bean mediates between the client and
the other components of the application,
presenting a simplified view to the client.

To improve performance, you might choose

a stateless session bean if it has any of these
traits:
The beans state has no data for a specific
client.
In a single method invocation, the bean
performs a generic task for all clients.
The bean fetches from a database a set of
read-only data that is often used by clients.

SERVLETS
Receives different client requests such as web
clients and cell clients and hands over the request
to EJB which in turn interacts with the data in the
database.
Validates the client requests on the basis of
business requirements and forwards the request to
appropriate programs.
Servlets are deployed as WAR files in weblogic
application server.

J2ME
The Java 2 Platform, Micro Edition (J2ME) is the Java
platform for consumer and embedded devices such as
mobile phones, PDAs, TV set-top boxes, in-vehicle
telematics systems, and a broad range of embedded devices.
The J2ME platform delivers the power and benefits of Java
technology tailored for consumer and embedded devices
including a flexible user interface, robust security model,
broad range of built-in network protocols, and support for
networked and disconnected applications.
With J2ME, applications are written once for a wide range
of devices, are downloaded dynamically, and leverage each
device's native capabilities.

ARCHITECTURE OF J2ME

 CONFIGURATION LAYER:
It is integrated with JVM.
Provides interactions between profile layer and JVM.
PROFILE LAYER:
It is a J2ME API layer where J2ME supporting software can
be downloaded from sun.java.com.
Provides lowlevel interface support for small computing
devices.
Provides interaction between MIDP layer and Configuration
layer
MIDP LAYER:
Provides the mechanism for network connection
management,persistence data management.
Uses CLDC libraries and MIDP libraries.

PRACTICAL REQUIREMENTS
When device is selected,install the
following:
Install JVM
Install CLDC(Connected Limited Device
Configuration) supporting software
Install MIDP(Mobile Infn Device Profile)

CLDC
Connection Limited Device Configuration
CLDC is one of the two J2EEconfigurations,
designed for devices with intermittent network
connections, slow processors and limited memory
devices such as mobile phones, two way pagers and
PDAs.
These devices typically have either 16- or 32-bit
CPUs or a minimum of 128 KB to 512 KB of
memory available for the Java platform
implementation and associated applications.

Mobile Information Device

Profile
The Mobile Information Device Profile (MIDP) is
designed for mobile phones and entry-level PDAs.
It offers the core application functionality required
by mobile applications, including the user
interface, network connectivity, local data storage,
and application management.
Combined with CLDC, MIDP provides a
complete Java runtime environment that leverages
the capabilities of handheld devices and minimizes
both memory and power consumption.

MIDLet
MIDLET is one of the applications of J2ME.
Like an applet, a MIDlet is a managed application.
Instead of being managed by a web browser, it is
managed by special-purpose
application-management software (AMS) built
into the device, often a cell phone or a two-way
interactive pager .

The MIDlet Life-Cycle

MIDlet's main class extends
javax.microedition.midlet.MIDlet. The main
class defines three life-cycle notification methods:
startApp(), pauseApp(), and
destroyApp().
There are three possible states in a MIDlet's life-cycle:
paused: The MIDlet instance has been constructed and is
inactive.
active: The MIDlet is active.
destroyed: The MIDlet has been terminated and is ready for
reclamation by the garbage collector.

SYSTEM ANALYSIS
EXISTING SYSTEM
seamless access to a wide array of content
and services, including applications, ring
tones, and images.
content developers want to bring products
to market faster by writing and packaging
their products once, then deploying them
anywhere.

 PROPOSED SYSTEM :
Meeting everyones needs requires a
standardized framework that enables
packaging content bundles and describing the
device capabilities required by each, so users
get the right content every timeautomatically
Java Specification Request (JSR) 124
the Java 2 Platform, Enterprise Edition (J2EE)
Client Provisioning Specificationhelps meet
the
challenge of this explosion in wireless
computing