14.Aim: Write an Android application program that demonstrates intent in mobile application development.

Procedure:An Intent is an object that provides runtime binding between separate components (such as two
activities). The Intent represents an app’s "intent to do something." You can use intents for a wide variety
of tasks, but most often they’re used to start another activity.
Inside the sendMessage() method, create an Intent to start an activity called DisplayMessageActivity:
Intent intent =newIntent(this,DisplayMessageActivity.class);
The constructor used here takes two parameters:

A Context as its first parameter (this is used because the Activity class is a subclass of
Context)
 The Class of the app component to which the system should deliver the Intent
Sending an intent to other apps:The intent created in this lesson is what's considered an explicit intent,
because the Intent specifies the exact app component to which the intent should be given. However, intents
can also be implicit, in which case the Intent does not specify the desired component, but allows any app
installed on the device to respond to the intent as long as it satisfies the meta-data specifications for the
action that's specified in various Intent parameters. For more information, see the class about Interacting
with Other Apps.
An intent not only allows you to start another activity, but it can carry a bundle of data to the activity as
well. Inside the sendMessage() method, use findViewById() to get the EditText element and add its text
value to the intent:
Intent intent =newIntent(this,DisplayMessageActivity.class);
EditText editText =(EditText) findViewById(R.id.edit_message);
String message = editText.getText().toString();
intent.putExtra(EXTRA_MESSAGE, message);
An Intent can carry a collection of various data types as key-value pairs called extras. The putExtra()
method takes the key name in the first parameter and the value in the second parameter.
In order for the next activity to query the extra data, you should define the key for your intent's extra using a
public constant. So add the EXTRA_MESSAGE definition to the top of the MainActivity class:
publicclassMainActivityextendsActivity{
publicfinalstaticString EXTRA_MESSAGE ="com.example.myfirstapp.MESSAGE";

...}

It's generally a good practice to define keys for intent extras using your app's package name as a prefix. This
ensures they are unique, in case your app interacts with other apps.
Start the Second Activity
To start an activity, call startActivity() and pass it your Intent. The system receives this call and starts an
instance of the Activity specified by the Intent. With this new code, the complete sendMessage() method
that's invoked by the Send button now looks like this:
/** Called when the user clicks the Send button */
publicvoidsendMessage(View view){
Intent intent =newIntent(this,DisplayMessageActivity.class);
EditText editText =(EditText) findViewById(R.id.edit_message);
String message = editText.getText().toString();

intent.putExtra(EXTRA_MESSAGE, message);
startActivity(intent); }
Now you need to create the DisplayMessageActivity class in order for this to work.
Create the Second Activity

Figure 1. The new activity wizard in Eclipse.

To create a new activity using Eclipse:
1. Click New in the toolbar.
2. In the window that appears, open the Android folder and select Android Activity. Click
Next.
3. Select BlankActivity and click Next.
4. Fill in the activity details:
o Project: MyFirstApp
o Activity Name: DisplayMessageActivity
o Layout Name: activity_display_message
o Title: My Message
o Hierarchial Parent: com.example.myfirstapp.MainActivity
o Navigation Type: None
Click Finish.
If you're using a different IDE or the command line tools, create a new file named
DisplayMessageActivity.java in the project's src/ directory, next to the original MainActivity.java file.
Open the DisplayMessageActivity.java file. If you used Eclipse to create this activity:


The class already includes an implementation of the required onCreate() method.
There's also an implementation of the onCreateOptionsMenu() method, but you won't need it
for this app so you can remove it.
There's also an implementation of onOptionsItemSelected() which handles the behavior for
the action bar's Up behavior. Keep this one the way it is.

Because the ActionBar APIs are available only on HONEYCOMB (API level 11) and higher, you must add
a condition around the getActionBar() method to check the current platform version. Additionally, you must
add the @SuppressLint("NewApi") tag to the onCreate() method to avoid lint errors.
The DisplayMessageActivity class should now look like this:
publicclassDisplayMessageActivityextendsActivity{
@SuppressLint("NewApi")
@Override
protectedvoid onCreate(Bundle savedInstanceState){
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_display_message);
if(Build.VERSION.SDK_INT >=Build.VERSION_CODES.HONEYCOMB){
getActionBar().setDisplayHomeAsUpEnabled(true);
} }
@Override
publicboolean onOptionsItemSelected(MenuItem item){
switch(item.getItemId()){
case android.R.id.home:
NavUtils.navigateUpFromSameTask(this);
returntrue;
}
returnsuper.onOptionsItemSelected(item); }}
If you used an IDE other than Eclipse, update your DisplayMessageActivity class with the above code.
All subclasses of Activity must implement the onCreate() method. The system calls this when creating a
new instance of the activity. This method is where you must define the activity layout with the
setContentView() method and is where you should perform initial setup for the activity components.
Add the title string
If you used Eclipse, you can skip to the next section, because the template provides the title string for the
new activity.
If you're using an IDE other than Eclipse, add the new activity's title to the strings.xml file:
<resources>
...
<stringname="title_activity_display_message">My Message</string>
</resources>
Add it to the manifest
All activities must be declared in your manifest file, AndroidManifest.xml, using an <activity> element.
When you use the Eclipse tools to create the activity, it creates a default entry. If you're using a different
IDE, you need to add the manifest entry yourself. It should look like this:
<application ... >
...
<activity
android:name="com.example.myfirstapp.DisplayMessageActivity"
android:label="@string/title_activity_display_message"
android:parentActivityName="com.example.myfirstapp.MainActivity">
<meta-data

android:name="android.support.PARENT_ACTIVITY"
android:value="com.example.myfirstapp.MainActivity"/>

</activity> </application>

The android:parentActivityName attribute declares the name of this activity's parent activity within the app's
logical hierarchy. The system uses this value to implement default navigation behaviors, such as Up
navigation on Android 4.1 (API level 16) and higher. You can provide the same navigation behaviors for
older versions of Android by using the Support Library and adding the <meta-data> element as shown here.
If you're developing with Eclipse, you can run the app now, but not much happens. Clicking the Send button
starts the second activity but it uses a default "Hello world" layout provided by the template. You'll soon
update the activity to instead display a custom text view, so if you're using a different IDE, don't worry that
the app won't yet compile.
Receive the Intent
Every Activity is invoked by anIntent, regardless of how the user navigated there. You can get the Intent that
started your activity by calling getIntent() and retrieve the data contained within it.
In the DisplayMessageActivity class’s onCreate() method, get the intent and extract the message delivered
by MainActivity:
Intent intent =getIntent();
String message = intent.getStringExtra(MainActivity.EXTRA_MESSAGE);
Display the Message
To show the message on the screen, create a TextView widget and set the text using setText(). Then add the
TextView as the root view of the activity’s layout by passing it to setContentView().
The complete onCreate() method for DisplayMessageActivity now looks like this:
@Override
publicvoidonCreate(Bundle savedInstanceState){
super.onCreate(savedInstanceState); Intent intent = getIntent();
String message = intent.getStringExtra(MainActivity.EXTRA_MESSAGE);
TextView textView =newTextView(this);
textView.setTextSize(40);
textView.setText(message);
setContentView(textView);}
You can now run the app. When it opens, type a message in the text field, click Send, and the message
appears on the second activity.
Figure 2.Both activities in the final app, running on Android 4.0.
Lab 13: output:

Lab 6:
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import java.io.*;
import javax.microedition.io.*;
public class SocketProg extends MIDlet implements CommandListener{
private Command exit,start;
private Display display;
private Form form;
public SocketProg() {
display=Display.getDisplay(this);
exit=new Command("Exit",Command.EXIT,1);
start=new Command("Start",Command.EXIT,1);
form=new Form("Read Write Socket");
form.addCommand(exit);
form.addCommand(start);
form.setCommandListener(this);
}
public void startApp() throws MIDletStateChangeException
{
display.setCurrent(form);
}
public void pauseApp() { }
public void destroyApp(boolean unconditional) { }
public void commandAction(Command command,Displayable displayable)
if(command==exit)
{
destroyApp(false);
notifyDestroyed();
}
else if(command==start)
{
try
{
StreamConnection connection = (StreamConnection)
Connector.open("http://172.25.1.150:80");
PrintStream output = new PrintStream(connection.openOutputStream());
output.println("GET/examples/websocket/echo.html HTTP/1.1\n\n");
output.flush();
InputStream in=connection.openInputStream();
int ch;
while( ( ch = in.read() )!= -1)
{
System.out.print( (char) ch);
}
in.close();
output.close();
connection.close();
}
catch(ConnectionNotFoundException error)
{
Alert alert=new Alert("Error","Cannot access socker.",null,null);

{

alert.setTimeout(Alert.FOREVER);
alert.setType(AlertType.ERROR);
display.setCurrent(alert);
}
catch( IOException error)
{
Alert alert=new Alert("Error",error.toString(),null,null);
alert.setTimeout(Alert.FOREVER);
alert.setType(AlertType.ERROR);
display.setCurrent(alert);
}
}
Alert alert=new Alert("Connection Successful!","Completed",null,null);
alert.setTimeout(Alert.FOREVER);
alert.setType(AlertType.INFO);
display.setCurrent(alert);
}}