Your SlideShare is downloading. ×
Intents in Android 4.x
Upcoming SlideShare
Loading in...5

Thanks for flagging this SlideShare!

Oops! An error has occurred.

Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Intents in Android 4.x


Published on

An introduction to Intents in Android 4.x …

An introduction to Intents in Android 4.x

The source code is available at

Published in: Education

1 Like
  • Be the first to comment

No Downloads
Total Views
On Slideshare
From Embeds
Number of Embeds
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

No notes for slide


  • 1. Intents Ilio Catallo, Eleonora Ciceri – Politecnico di Milano,
  • 2. Agenda ¤  Event handling ¤  Event handling vs. layout file ¤  TakeNotes V3 implementation ¤  Intents ¤  What is an Intent? ¤  Launching an Activity ¤  TakeNotes V3 implementation 2
  • 3. Event handling vs. layout file 3
  • 4. Event handling vs. layout file Callback methods ¤  Already present in the View class Event listeners ¤  Nested interfaces + Customized implementation 4 . . . . . .
  • 5. Event handling vs. layout file ¤  Sometimes there are views that do not need to change during run-time 5 The “+” button ü  Used to add new items to the list ü  It is loaded at runtime ü  Its behavior remains unchanged during the execution ü  Its aspect remains unchanged during the execution
  • 6. Event handling vs. layout file Changes on the view ¤  Causes ¤  It is created during the execution (e.g., new to- do item) ¤  Approach ¤  The listener is added programmatically ¤  Example ¤  Checkboxes vs. onClick! View is unaltered ¤  Causes ¤  It represents a static behavior of the application ¤  Approach ¤  Define its aspect and behavior in layout file ¤  Example ¤  “+” button 6
  • 7. Event handling vs. layout file 7 associated with described in This is a reference to the button that was clicked
  • 8. Event handling vs. layout file ¤  To correctly locate the callback method from its name as specified in the layout file, the callback method must: ¤  Be public ¤  Have a void return value ¤  Specify a View as the only parameter (i.e., the View that was clicked) ¤  Example: public void addNewToDo(View v)! 8
  • 9. TakeNotes v3: add a new item ¤  In the previous TakeNotes version we have seen how to delete an item from the to do list ¤  We are now going to add a new item to the do to list ¤  Use case: ¤  The user presses the + button ¤  A form appears, requiring the item description ¤  The user inserts the text and confirms the action ¤  The new checkbox appears in the to do list 9
  • 10. TakeNotes v3: The + button ¤  We define a + button that, if clicked, starts the procedure used for adding an item to the to do list ¤  where the requireNewToDo is a method defined in the ToDoListActivity class that will be invoked when the user clicks the button 10 <Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="@string/button_requireAdd" android:onClick="requireNewToDo"/>
  • 11. TakeNotes v3: The + button 11
  • 12. Intents 12
  • 13. Intents ¤  An Intent is an abstract description of an operation to be performed ¤  It can be thought as a message that is passed between components ¤  The message contains instructions for executing a specific action ¤  An intent involves two subjects: ¤  The sender wants a job to be performed and thus publishes a message (i.e., an intent) ¤  The receiver is any component which is able to perform the requested job 13
  • 14. Exampleof(Implicit) Intent 14 Intent Action: play video Data: URL Browser application YouTube application
  • 15. What Intents are good at ¤  Intents are used in a variety of situations: ¤  Taking pictures from the camera ¤  Starting a new web search ¤  Sending e-mails ¤  Sending SMS’s ¤  All these features take advantage of the most significant use of Intents, i.e., launching new Activities 15
  • 16. Explicit and implicit Intents ¤  There exist only two ways of launching a new Activity: ¤  By name: you know the exact name of the Activity you want to launch ¤  By action: you want something to be done for you (e.g., taking a picture) ¤  Consequently, Android provides two kinds of Intents: ¤  Explicit intents, which specify the exact Activity to which the Intent should be given ¤  Implicit Intents, which do not declare the name of the Activity to start, but instead declare an action to perform 16
  • 17. Explicit Intents (1) ¤  Explicit Intents are typically used for launching new Activities within the same application ¤  Nothing in the Intent object other than the name of the Activity to be launched matters ¤  All other fields (action, data, category) are null! 17 Intent intent = new Intent(this, NewActivity.class);
 ! Context The calling Activity is used as a Context object in order to determine the package where to look for the NewActivity class
  • 18. Implicit Intents (1) ¤  Each implicit Intent contains information useful to the receiver for performing the job: ¤  Action: the job that the sender can require to perform ¤  Data: the data on which the job will run ¤  Category: the execution requirements (e.g., of being executed in a browser) 18 Intent in = new Intent(Intent.ACTION_DIAL, Uri.parse("tel:0223993669")); ! Action Making a phone call Data The phone number
  • 19. Implicit Intents (2) ¤  The system determines which Activity is best to run based on the fields (e.g., action) of the implicit Intent ¤  If more than one Activity can handle the Intent, a dialog for the user to select which app to use is displayed 19
  • 20. Implicit intents vs. explicit intents 20 Activity 1 Activity 2 Intent Resolution Explicit Intent: “Execute Activity3” Implicit Intent: “Send a new e-mail” Activity 3 Fancy e-mail client Humble e-mail client User decides which client to use
  • 21. Launching an Activity (1) ¤  To start an activity, call the startActivity(Intent) method ¤  Once the startActivity(Intent) method is invoked ¤  In case of implicit intent, the resolution mechanism identifies the Activity that best matches the intent fields ¤  In case of explicit intent, the system receives the call and starts an instance of the Activity specified by the Intent! 21 Intent intent = ..." startActivity(intent);!
  • 22. Launching an Activity (2) ¤  It is possible to pass some parameters to the started Activity by adding them as extra content of the Intent! 22 Intent intent = ..." intent.putExtra(EXTRA_MESSAGE, myMessage);
  • 23. Launching an Activity (3) ¤  Within the just-started Activity, you can inspect the received Intent by using the getIntent() method ¤  Useful to retrieve the data contained in the Intent ¤  This is usually done in the onCreate() method of the new Activity 23 Intent intent = getIntent();
 String message = intent.getStringExtra(EXTRA_MESSAGE);!
  • 24. Receiving implicit Intents ¤  How to inform the system that an Activity can handle a specific type of implict Intent? ¤  This can be done by advertising that a given Activity can manage a specific implicit Intent, i.e., by associating the Activity with an Intent filter ¤  An Intent filter: ¤  declares the capability of an Activity of receiving implicit Intents of a specific type ¤  delimits the Intents an Activity can handle 24
  • 25. Example: dialing a number (1) ¤  In order to declare an Intent filter, you need to add an <intent-filter> element in your manifest file for the corresponding <activity> element ¤  Example: we declare that the Activity can act as a dialer 25 <intent-filter> <action android:name="android.intent.action.DIAL" /> <category android:name="android.intent.category.DEFAULT" /> <data android:scheme="tel"/> </intent-filter>
  • 26. Example: dialing a number (2) ¤  Everytime an implicit intent of type android.intent.action.DIAL is casted: ¤  Our Activity is listed as a candidate: 26 Intent in = new Intent(Intent.ACTION_DIAL, Uri.parse("tel:0223993669")); startActivity(in);
  • 27. Example: launching an app ¤  Look in your AndroidManifest.xml file: ¤  You will find an intent filter associated with the main Activity ¤  The intent filters declares that the main activity can receive an implicit Intent coming from the Launcher ¤  Such a implicit intent corresponds to the user’s action of launching the application 27 <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter>
  • 28. Requesting a result from an Activity (1) ¤  Starting another Activity does not have to be one-way ¤  You can start a second Activity and receive a result back ¤  Examples ¤  Start the camera and receive the photo as a result ¤  Start the People app and receive a contact details as a result 28
  • 29. Requesting a result from an Activity (2) 29 Activity 1 Camera Activity Implicit Intent: “Take a picture” Calling (first) Activity Called (second) Activity
  • 30. Requesting a result from an Activity (3) ¤  The Intent you pass is the same you could use to start an Activity without requiring a result back ¤  Just call startActivityForResult() instead of startActivity()! ¤  You need to pass an additional integer argument, that represents a request code that identifies the request 30 Intent intent = ... " startActivityForResult(intent, MY_REQUEST_CODE);!
  • 31. Returned data (1) ¤  As soon as the user is done with the called Activity, the result will be sent back to the first Activity ¤  Along with the actual result, additional information is returned from the called Activity to the calling Activity: ¤  The request code originally sent by the calling Activity ¤  A result code to notify that the operation in the called Activity has been successful ¤  Insight: Activity result codes have the same role as the HTTP status codes 31
  • 32. Returned data (2) 32 Activity 1 Camera Activity (, TAKE_PICTURE*) Calling (first) Activity Called (second) Activity < , TAKE_PICTURE, RESULT_OK> * where TAKE_PICTURE is a int constant representing the request code
  • 33. Processing the returned data ¤  When the second Activity returns, the system invokes the onActivityResult() method on the calling Activity ¤  The data are sent back to the calling Activity as an Intent 33 @Override
 protected void onActivityResult(int requestCode,int resultCode,Intent data) {
 if (requestCode == MY_REQUEST_CODE)
 if (resultCode == RESULT_OK)
  • 34. Role of the request code (1) ¤  The calling Activity uses different request codes to distinguish between different types of requests ¤  When receiving a result, the calling Activity uses the request code to identify the provenance of the result ¤  The request codes only makes sense for the calling Activity, while they do not have any particular meaning for the called Activity 34
  • 35. Role of the request code (2) 35 Activity 1 Activity 4 Activity 3 Activity 2 Request code: 1! Request code: 2! Request code: 3!
  • 36. Role of the request code (3) 36 Request code: 1! Activity 2 Activity 1 Activity 4 Activity 3 The data come from Activity 2, as the request code bundled with the result is 1!
  • 37. Returning data from an Activity ¤  In case the called Activity is part of our application, we have to deal also with the problem of returning data to the calling Activity ¤  We need to: ¤  Perform the operation for which we launched the second Activity ¤  Pack the result into an Intent object ¤  Determine the result code ¤  Terminate the called Activity 37
  • 38. Performing the operation in the called Activity ¤  An Activity represents a task the user can achieve ¤  To this end, it may be possible for the calling Activity to provide some parameters to the second Activity ¤  These parameters are sent within the Intent as extra’s ¤  We already know how to inspect the triggering Intent within the second Activity: 38 Intent intent = getIntent();
 String message = intent.getStringExtra(EXTRA_MESSAGE);!
  • 39. Packing the result into an Intent object ¤  The called Activity produces a result of some kind ¤  These data can be packed into an Intent by using the Intent’s putExtra() method 39 Intent intent = new Intent(); intent.putExtra("KeyForResult1", result1); intent.putExtra("KeyForResult2", result2); We use the default constructor, since we do not know anything about the calling Activity (but the OS knows for us)
  • 40. Determining the result code ¤  The operation performed in the called Activity may succeed or fail, and the resulting data may change accordingly ¤  You can set the result and the corresponding result code as follows: 40 Intent data = new Intent(); data.putExtra(...) .... setResult(RESULT_OK, data); We use the default constructor, since we do not know anything about the calling Activity (but the OS knows for us)
  • 41. Terminating the called Activity (1) ¤  The Intent containing the result will not be fired until the called Activity is running ¤  It is the Operating System (OS) that passes Intents between different components ¤  No communication occurs as long as the control does not return to the OS ¤  Hence, when the user is done with the Activity, it has to be terminated 41
  • 42. Terminating the called Activity (2) ¤  Usually, it is up to the Operating System to decide when to terminate an Activity ¤  However, is some cases the user performs an operation of the UI that indicates that he is done with the current Activity ¤  To manually terminate an Activity we can use the finish() method 42 Intent data = new Intent(); data.putExtra(...) .... setResult(RESULT_OK, data); finish()
  • 43. TakeNotes v3: require a new to do ¤  When the + button is clicked, a new to do is required ¤  The input form containing the to do data is launched in a second Activity (AddToDoActivity) ¤  We require the execution of the second Activity, expecting it to return a result (i.e., the to do description) 43 Intent intent = new Intent(this, AddToDoActivity.class);
 startActivityForResult(intent, REQUIRE_NEW_TODO);! Request code, stored in public static final int REQUIRE_NEW_TODO = 0;!
  • 44. TakeNotes v3: input the new to do ¤  The interface is built in the layout file (res/layout/) 44 <LinearLayout [...]> <EditText android:id="@+id/toDoContent" [...]/> <Button [...] android:onClick="addToDoToList"/> </LinearLayout>
  • 45. TakeNotes v3: return the result (1) ¤  When the user clicks on the button, the to-do item has to return to the first activity (ToDoListActivity) ¤  To do so, we collect the result from the AddToDoActivity activity and send it back with an Intent ¤  The Intent will report the to-do description as extra content ¤  Once the Intent is sent, the AddToDoActivity activity is closed using the finish() instruction 45
  • 46. TakeNotes v3: return the result (2) 46 public void addToDoToList(View view) { Intent intent = new Intent(this, ToDoListActivity.class); EditText editText = (EditText) findViewById(; String newContent = editText.getText().toString(); intent.putExtra(TODO_CONTENT, newContent); setResult(RESULT_OK, intent); finish(); } Called when the button is pressed Terminate the Activity and release the intent
  • 47. @Override
 public void onActivityResult(int requestCode, int resultCode, Intent intent) {
 super.onActivityResult(requestCode, resultCode, intent);
 if (requestCode == REQUIRE_NEW_TODO &&" resultCode == RESULT_OK)
 if (intent != null)
 addNewToDoToList(" " "intent.getStringExtra(AddToDoActivity.TODO_CONTENT));
 }! TakeNotes v3: receive the result 47 ¤  The result is now returned to ToDoListActivity and needs to be processed ¤  All the results coming from an Intent are collected by the onActivityResult method Verify the request code so as to identify the correct result
  • 48. TakeNotes v3: add to do to list ¤  We retrieved the item description, not the checkbox ¤  The next steps are: ¤  Build the checkbox ¤  Add the checkbox to the list linear layout 48 CheckBox newToDoCheckBox = new CheckBox(this);
 LinearLayout linearLayout = (LinearLayout) " " " "findViewById(;
 linearLayout.addView(newToDoCheckBox);! See TakeNotes v2
  • 49. References 49
  • 50. References ¤  Android Training, Starting an Activity activity.html ¤  Android Training, Getting a Result from an Activity ¤  Android API Guides, Intent and Intent Filters filters.html ¤  Android Training, Sending the User to Another App ¤  Android Training, Allowing other Apps to Start Your Activity 50