Following this Method......
private TextToSpeech tts; tts = new TextToSpeech(this, this);
public void onInit(int status) {
// TODO Auto-generated method stub if (status == TextToSpeech.SUCCESS) { int result = tts.setLanguage(Locale.US); //tts.setPitch(0.5f); // set pitch level tts.setSpeechRate(1); // set speech speed rate if (result == TextToSpeech.LANG_MISSING_DATA || result == TextToSpeech.LANG_NOT_SUPPORTED) { Log.e("TTS", "Language is not supported"); } else { speakOut(); } } else { Log.e("TTS", "Initilization Failed"); } } @Override public void onDestroy() { // Don't forget to shutdown! if (tts != null) { tts.stop(); tts.shutdown(); } super.onDestroy(); } private void speakOut() { tts.speak(traintime, TextToSpeech.QUEUE_ADD, null); tts.speak(bustime, TextToSpeech.QUEUE_ADD, null); }
I would suggest adding some
logging into your code to see where it is failing.
Firstly, try putting tts = null; after tts.shutdown(); in onDestroy()
If that doesn't work, check the
status onInit. At the moment your code handles success, but you appear
to do nothing if you get a fail message message.
Put logging in the OnStart and OnInit to check you are correctly calling them - it may be an
error somewhere in your code that you are not detailing above.
|
Speak failed not bound to TTS Engine
difference between sendredirect and requestdispatcher
SendRedirect ():
This method is declared in HttpServletResponse Interface.
Forward():
This method is declared in RequestDispatcher Interface.
Signature: forward(ServletRequest request, ServletResponse response)
This method is used to pass the request to another resource for further processing within the same server,
another resource could be any servlet, jsp page any kind of file.This
process is taken care by web container when we call forward method
request is sent to another resource without the client being informed,
which resource will handle the request it has been mention on
requestDispatcher object which we can get by two ways either using
ServletContext or Request. This is also called server side redirect.
RequestDispatcher rd = request.getRequestDispatcher("pathToResource");
rd.forward(request, response);
rd.forward(request, response);
Or
RequestDispatcher rd = servletContext.getRequestDispatcher("/pathToResource");
rd.forward(request, response);
rd.forward(request, response);
Difference between SendRedirect and Forward
Now let’s see some difference between these two method of servlet API in tabular format.
Forward()
|
SendRediret()
|
When we use forward method request is transfer to other resource within the same server for further processing.
|
In case of sendRedirect request is transfer to another resource to different domain or different server for futher processing.
|
In case of forward Web container handle all process internally and client or browser is not involved.
|
When you use SendRedirect container transfers the request to client or browser so url given inside the sendRedirect method is visible as a new request to the client.
|
When forward is called on requestdispather
object we pass request and response object so our old request object
is present on new resource which is going to process our request
|
In case of SendRedirect call old request and response object is lost because it’s treated as new request by the browser.
|
Visually we are not able to see the forwarded address, its is transparent
|
In address bar we are able to see the new redirected address it’s not transparent.
|
Using forward () method is faster then send redirect.
|
SendRedirect is slower because one extra round trip is required beasue completely new request is created and old request object is lost.Two browser request requird.
|
When
we redirect using forward and we want to use same data in new resource
we can use request.setAttribute () as we have request object available.
|
But in sendRedirect if we want to use we have to store the data in session or pass along with the URL.
|
Example of forward and SendRedirect in JSP Servlet:
Any kind of online payment when we use merchant site will redirect us to net banking site which is completely new request it process our request and again redirect to merchant site?
In
Banking Application when we do login normally we use forward method. In
case of online banking we are asked for username and password if it’s a
correct some another servlet or resource will handle the request other
wise request has been forwarded to error page.
Which one is good?
Its depends upon the scenario that which method is more useful.
If you want control is transfer to new server or context and it is treated as completely new task then we go for Send Redirect.
Normally
forward should be used if the operation can be safely repeated upon a
browser reload of the web page will not affect the result.
SendRedirect and forward method are still very useful while programming or working on any web application project using servlet jsp. This is still a popular interview questions so don’t forget to revise forward and sendRedirect before appearing for any job interview.
RequestDispatcher cannot be resolved to a type in eclipse
servlet api jar is missing .....
Check the libraries of your project properties . Check Configure your buildpath and Libraries
- removes and added JRE library
- removed and added server(Tomcat 7.0.23) servlet api jar file
- clean project.
Difference between an application server and a Web server?
Taking
a big step back, a Web server serves pages for viewing in a Web browser, while
an application server provides methods that client applications can call. A
little more precisely, you can say that:
A Web server exclusively handles HTTP requests, whereas an
application server serves business logic to application programs through any
number of protocols.
Let's examine each in more detail.
The
Web server
A Web server handles the HTTP
protocol. When the Web server receives an HTTP request, it responds with an
HTTP response, such as sending back an HTML page. To process a request, a Web
server may respond with a static HTML page or image, send a redirect, or
delegate the dynamic response generation to some other program such as CGI
scripts, JSPs (JavaServer Pages), servlets, ASPs (Active Server Pages),
server-side JavaScripts, or some other server-side technology. Whatever their
purpose, such server-side programs generate a response, most often in HTML, for
viewing in a Web browser.
Understand that a Web server's
delegation model is fairly simple. When a request comes into the Web server,
the Web server simply passes the request to the program best able to handle it.
The Web server doesn't provide any functionality beyond simply providing an
environment in which the server-side program can execute and pass back the
generated responses. The server-side program usually provides for itself such
functions as transaction processing, database connectivity, and messaging.
While a Web server may not itself
support transactions or database connection pooling, it may employ various
strategies for fault tolerance and scalability such as load balancing, caching,
and clustering—features oftentimes erroneously assigned as features reserved
only for application servers.
The
application server
As for the application server,
according to our definition, an application server exposes business logic to
client applications through various protocols, possibly including HTTP. While a
Web server mainly deals with sending HTML for display in a Web browser, an
application server provides access to business logic for use by client
application programs. The application program can use this logic just as it
would call a method on an object (or a function in the procedural world).
Such application server clients can
include GUIs (graphical user interface) running on a PC, a Web server, or even
other application servers. The information traveling back and forth between an
application server and its client is not restricted to simple display markup.
Instead, the information is program logic. Since the logic takes the form of
data and method calls and not static HTML, the client can employ the exposed
business logic however it wants.
In most cases, the server exposes
this business logic through a component API, such as the EJB (Enterprise
JavaBean) component model found on J2EE (Java 2 Platform, Enterprise Edition)
application servers. Moreover, the application server manages its own resources.
Such gate-keeping duties include security, transaction processing, resource
pooling, and messaging. Like a Web server, an application server may also
employ various scalability and fault-tolerance techniques.
An example
As an example, consider an online store that provides real-time pricing and availability information. Most likely, the site will provide a form with which you can choose a product. When you submit your query, the site performs a lookup and returns the results embedded within an HTML page. The site may implement this functionality in numerous ways. I'll show you one scenario that doesn't use an application server and another that does. Seeing how these scenarios differ will help you to see the application server's function.Scenario 1: Web server without an application server
In the first scenario, a Web server alone provides the online store's functionality. The Web server takes your request, then passes it to a server-side program able to handle the request. The server-side program looks up the pricing information from a database or a flat file. Once retrieved, the server-side program uses the information to formulate the HTML response, then the Web server sends it back to your Web browser.To summarize, a Web server simply processes HTTP requests by responding with HTML pages.
Scenario 2: Web server with an application server
Scenario 2 resembles Scenario 1 in that the Web server still delegates the response generation to a script. However, you can now put the business logic for the pricing lookup onto an application server. With that change, instead of the script knowing how to look up the data and formulate a response, the script can simply call the application server's lookup service. The script can then use the service's result when the script generates its HTML response.In this scenario, the application server serves the business logic for looking up a product's pricing information. That functionality doesn't say anything about display or how the client must use the information. Instead, the client and application server send data back and forth. When a client calls the application server's lookup service, the service simply looks up the information and returns it to the client.
By separating the pricing logic from the HTML response-generating code, the pricing logic becomes far more reusable between applications. A second client, such as a cash register, could also call the same service as a clerk checks out a customer. In contrast, in Scenario 1 the pricing lookup service is not reusable because the information is embedded within the HTML page. To summarize, in Scenario 2's model, the Web server handles HTTP requests by replying with an HTML page while the application server serves application logic by processing pricing and availability requests.
Use of Wrapper classes in java
Introduction
Java
is an object-oriented language and can view everything as an object. A simple
file can be treated as an object (with java.io.File), an address of a
system can be seen as an object (with java.util.URL), an image can be
treated as an object (with java.awt.Image) and a simple data type can be
converted into an object (with wrapper classes). This tutorial discusses
wrapper classes. Wrapper classes are used to convert any data type into
an object.
The
primitive data types are not objects; they do not belong to any class; they are
defined in the language itself. Sometimes, it is required to convert data types
into objects in Java language. For example, upto JDK1.4, the data structures
accept only objects to store. A data type is to be converted into an object and
then added to a Stack or Vector etc. For this conversion, the designers
introduced wrapper classes.
What are Wrapper
classes?
As
the name says, a wrapper class wraps (encloses) around a data type and gives it
an object appearance. Wherever, the data type is required as an object, this
object can be used. Wrapper classes include methods to unwrap the object and
give back the data type. It can be compared with a chocolate. The manufacturer
wraps the chocolate with some foil or paper to prevent from pollution. The user
takes the chocolate, removes and throws the wrapper and eats it.
Observe the following
conversion.
int k = 100;
Integer it1 = new Integer(k);
Integer it1 = new Integer(k);
The
int data type k is converted into an object, it1 using Integer
class. The it1 object can be used in Java programming wherever k
is required an object.
The
following code can be used to unwrap (getting back int from Integer
object) the object it1.
int
m = it1.intValue();
System.out.println(m*m); // prints 10000 -
System.out.println(m*m); // prints 10000 -
intValue() is a method of Integer class
that returns an int data type.
List
of Wrapper classes
In
the above code, Integer class is known as a wrapper class (because it
wraps around int data type to give it an impression of object). To wrap (or to
convert) each primitive data type, there comes a wrapper class. Eight wrapper
classes exist in java.lang package that represent 8 data types.
Following list gives.
Following is the hierarchy of the above classes. –
All
the 8 wrapper classes are placed in java.lang package so that they are
implicitly imported and made available to the programmer. As you can observe in
the above hierarchy, the super class of all numeric wrapper classes is Number
and the super class for Character and Boolean is Object. All the
wrapper classes are defined as final and thus designers prevented them
from inheritance.
Importance
of Wrapper classes
There
are mainly two uses with wrapper classes.
1.
To
convert simple data types into objects, that is, to give object form to a data
type; here constructors are used.
2.
To
convert strings into data types (known as parsing operations), here methods of
type parseXXX() are used.
The
following program expresses the style of converting data type into an object
and at the same time retrieving the data type from the object.
Subscribe to:
Posts (Atom)