Develop Reference

Do implicit intents do a broadcast internally?

Following piece of code open an URL using implicit intent.
EditText editText = (EditText) findViewById(R.id.url_editText);
Intent myIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(editText.getText().toString()));
startActivity(myIntent);
It shows up all the applications that support this action Intent.ACTION_VIEW like Chrome, Firefox etc. Hence I am assuming this procedure internally does a broadcast with action Intent.ACTION_VIEW. Please correct me if I have misunderstood.
As per above assumption I tried the foloowing code
Intent myIntent = new Intent(Intent.ACTION_VIEW);
sendBroadcast(myIntent);
but it does not work. Nothing is shown. What is the difference. Can someone clear my confusion?

This has to do with IntentFilters. Before launching the Activity, it's asking the system to give it the list of everything that's an Activity and can handle the intent -- no broadcasting involved here.
As for sendBroadcast() -- it's essentially the same thing but for BroadcastReceivers. The mechanism is the same: match intent filters, deliver the Intent, but the Intent is delivered to all the receivers regardless of their quantity (as opposed to what startActivity() does -- because it can only result in starting a single activity, hence the need to choose one if there are multiple that match).
I don't think there are any BroadcastReceivers registered for Intent.ACTION_VIEW (since it's an action whose purpose is to start an activity, there's no logical reason to listen for it and start nothing, except count activity launches or something) but you can register one yourself and see what happens.

Hence I am assuming this procedure internally does a broadcast with action Intent.ACTION_VIEW.
No.
but it does not work. Nothing is shown
Of course.
What is the difference.
startActivity() != sendBroadast(). They are separate operations, just as addition and subtraction are separate mathematical operations.
If you wish to think of the Intent system as being a bit like a message bus, that bus has three totally separate channels:
activities (startActivity())
services (startService(), bindService())
broadcasts (sendBroadcast(), sendOrderedBroadcast(), etc.)

The difference between those two is just who receives the Intent. If you call sendBroadcast() the Intent will be sent to BroadcastReceivers. If you call startActivity() the Intent will be sent to Activities. That's the reason why this:
Intent myIntent = new Intent(Intent.ACTION_VIEW);
sendBroadcast(myIntent);
Doesn't start an Activity, because the Intent is only visible to BroadcastReceivers.
The same goes for startService(). By calling that method the Intent will only target Services. I guess the confusion comes from the word broadcast. It implies that it is sent everywhere and visible to everyone, but that is not the case. Broadcasts are only visible to BroadcastReceivers just like if you call startActivity() the Intent will only target Activities and nothing else.
You can find more information here.

How to "release" intent in Android?

I have two Activities in my Android app that deal with NFC. One has a declared IntentFilter in the AndroidManifest.xml, while the other just accepts NFC actions while it is active using a PendingIntent and onNewIntent();. However, sometimes when in the latter activity I actually want to pass the NFC action on the the former. How do I "release" the Intent to a different activity without losing any of the NFC information within?

Use startActivity(Intent intent) but instead of the Intent being created using the specific MyActivity.class form (an explicit Intent), add the action/category that the first Activity is set to react to in its manifest <intent-filter> section (an implicit Intent).

What is the different between Explicit and implicit activity call in android?

What is the difference between explicit and implicit activity call in android? If you explain the answer with a simple example will be good.

For example:
implicit activity call
In intent filter you create action for you activity, so other app can call your activity via this action as following:
<activity android:name=".BrowserActivitiy" android:label="#string/app_name">
<intent-filter>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<data android:scheme="http"/>
</intent-filter>
</activity>
And the other way to call implicit Intent is below:
Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse("http://www.example.com"));
startActivity(intent);
Explicit activity call
You make a call that indicate exactly which activity class:
Intent intent = new Intent(this, ActivityABC.class);
intent.putExtra("Value", "This value for ActivityABC");
startActivity(intent);
Hope this help you understand more about Explicit and implicit activity call in android.
You can get more detail about Android Intent here

Explicit Intents are used to call a specific component. When you know which component you want to launch and you do not want to give the user free control over which component to use.For example, you have an application that has 2 activities. Activity A and activity B. You want to launch activity B from activity A. In this case you define an explicit intent targeting activityB and then use it to directly call it.
Implicit Intents are used when you have an idea of what you want to do, but you do not know which component should be launched. Or if you want to give the user an option to choose between a list of components to use. If these Intents are send to the Android system it searches for all components which are registered for the specific action and the data type. If only one component is found, Android starts the component directly. For example, you have an application that uses the camera to take photos. One of the features of your application is that you give the user the possibility to send the photos he has taken. You do not know what kind of application the user has that can send photos, and you also want to give the user an option to choose which external application to use if he has more than one. In this case you would not use an explicit intent. Instead you should use an implicit intent that has its action set to ACTION_SEND and its data extra set to the URI of the photo.
An explicit intent is always delivered to its target, no matter what it contains; the filter is not consulted. But an implicit intent is delivered to a component only if it can pass through one of the component's filters

Every time I get confused among these in either interview. So, I have summarised it like this, may it help someone to keep this difference in mind.
Summary:
In Implicit Intents, the user implicitly tells the system WHAT should be done, without specifying who should do.
In Explicit Intents, the user explicitly tells the system WHOM to be triggered for whatever the work is.

See Intent Resolution here
http://developer.android.com/guide/topics/intents/intents-filters.html
Explicit intents (activities) refer to a specific class, and in general, are only available to your packages. Implicit intents refer to intent filters where apps publicly announce that they can handle certain types of data or can provide specific services, e.g. send an email. With implicit intents, the users chooses which activity (typically a package) to use to handle the intent or if a default handler is set, it is launched.

When to use which?
Explicit intent: When you know which component can handle your request. So you explicitly mention that component name in the intent.
Intent i = new Intent(context,DetailActivity.class); // DetailActivity.class is the component name
startActivity(i);
Implicit intent: When you don't know which application can handle your request then you mention the action in intent and let the OS decide which application/s is/are suitable for your task.
Example: Play music
Intent intent = new Intent();
intent.setAction(Intent.ACTION_VIEW);
intent.setData(file);
startActivity(intent);
How OS decides?
When there is implicit call with an intent then OS takes out the action and then it matches with all the intent-filters of all the registered activities of all application using PackageManager and then populates the result as a list. It is called intent resolution
So there is a possibility that no application is available in your device which can handle your request. In that case, you will get NullPointer Exception.
So a safer way to call implicit intent would be this
Intent intent = new Intent(Intent.ACTION_VIEW);
intent.setData(file);
if (intent.resolveActivity(getPackageManager()) != null) {
startActivity(intent);
}

There are two types of intents:
Explicit Intent:
While creating an Intent object when we explicitly specify and pass on the target component name directly in the intent, it’s an explicit intent.
Implicit Intent:
In this case we delegate the task of evaluating the registered components (registration is usually done using intent filters that we’ll cover later) to Android based on the intent data and the intended action (like send an email, capture a photo, pin location on a map, etc.) that we pass. So Android will automatically fire up the component from the same app or some other app that can handle the intent message/job. The idea in this case is that, let’s say we have to pin a location on a map, for that we don’t have to code our own activity to handle that. Instead just pass on the location data to an app like Google maps that can do the job on our app’s behalf.
source : http://codetheory.in/android-intents/

Implicit intent doesn't specify the component. Intent provides the information of a component
Intent intent=new Intent(Intent.ACTION_VIEW);
intent.setData(Uri.parse("http://www.google.com"));
startActivity(intent);
whereas,
Explicit intent specify the component. The intent provides information about the class.
Intent i = new Intent(this, ClassB.class);
startActivity(i);

difference between intent and intenfilter in android

Hi friends
can anybody tell what is the use of intent filter and what is difference between intent and intent filter
Thanks

An Intent is an object passed to Context.startActivity(),Context.startService() or Activity.startActivityForResult() etc. to launch an activity or get an existing activity to do something new.
While an Intent filter describes a capability of the component(like activities, services, and broadcast receivers )
For more details see this

Intent's are used to start new activity from the current activity. With two ways
1) Activity.startActivity(intent);
2) Activity.startActivityForResult(intent,rqwuestCode);
//The above thing's you need to put in .java file
Intent-filter you need to mention on manifeast file.
// Intent filter are used for broadcast receiver. Whenever the intent filter condition is match the android OS will launch that activity.

An intent is an object that can hold the os or other app activity and its data in uri form.It is started using startActivity(intent-obj)..\n whereas IntentFilter can fetch activity information on os or other app activities.

What are Intent Filters exactly?

I've read lots of articles about intent filters and I really can't understand exactly what they do?
so please if anybody can explain to me with a clear example what is the role of intent filters exactly ?
thanks

I think it's well documented here. Summarizing, when (e.g.) you pass an intent to Context.startActivity, or Context.startService, or broadcast it with Context.sendBroadcast, etc, what activity or service (or, what set of broadcast receivers) is the intent delivered to?
Answer: if the intent is "explicit", i.e., it has the component name field set, then it's delivered to the target component it designates -- this typically happens in communication within an application.
Otherwise ("implicit" intent, as is typical for communication between applications), Android must determine the best activity or service (or set of receivers) on its own. How does Android do that? That's where filters come in, and I quote:
It does so by comparing the contents
of the Intent object to intent
filters, structures associated with
components that can potentially
receive intents. Filters advertise the
capabilities of a component and
delimit the intents it can handle.
They open the component to the
possibility of receiving implicit
intents of the advertised type. If a
component does not have any intent
filters, it can receive only explicit
intents. A component with filters can
receive both explicit and implicit
intents.
The web page in question continues with many details and, at the end, a complete, simple example, and I think it would be redundant to copy and paste them here.

Simply put, Intent filters are a way of telling the OS how to launch/communicate with the different activities/services/broadcast receivers in your app. So for example, if you want links that start with http://www.mycompany.com to lead people into your app, an intent filter is the way to accomplish that. Once its setup, anytime someone clicks on a link that starts with that (in any app) the user will be presented with the option to use your app to view that page. You've probably seen this with youtube urls. Likewise, if you want the 'share' link commonly seen in many apps to list your app, would use an intent filter to do that.
hope this helps...

An intent filter lets the system know what data or service requests a component can handle. A component might be an activity, service or broadcast receiver.
If you are writing an image viewer, you would add an intent filter (or several) to the manifest describing the images you can handle. If you are writing a file browser, you might package up the details of an image file in an intent, and the system would sift through intent filters until it found a best match to handle that image. The same goes for any type of data or service that might be passed from one component to the next.

Intent Filters is a way of telling OS that let me handle/provide these kind of Activities/Services
By adding given filter to Manifest tells OS that i can also handle Sms service and whenever you send sms it will show in a list or you can also explicitly use this as your sms service.
<intent-filter>
<action android:name="android.intent.action.SENDTO" />
<action android:name="com.example.code.SMS_INTENT" />
<category android:name="android.intent.category.DEFAULT" />
<data android:scheme="smsto" />
</intent-filter>
And to explicitly using this service call it like ...
Intent intent = new Intent("com.example.code.SMS_INTENT", Uri.parse(uri));
intent.putExtra("from", "code");
startActivity(intent);

IntentFilters are used to declare a pattern of Intent attributes that the declaring component will respond to. You can specify with an IntentFilter that a given Activity, Service or BroadcastReceiver will respond to a combination of action, data mime type, scheme, path, etc. For example if you register an Activity with IntentFilter for ACTION_SEND with data type "text/plain", your Activity will be called each time the users wants to send some text.

intentFilters advertise the capabilities of a component and delimit
the intents that can handle. an IntentFilter that a given Activity,
Service or BroadcastReceiver will respond to a combination of action,
data mime type, scheme, path, etc.
The intent by comparing the intent to intent filters based on three
aspects:
1:- The intent action 2:- The intent data (both URI and data type) 3:- The intent
category
action : Declares the intent action accepted, in the name
attribute. The value must be the literal string value of an action,
not the class constant.
data : Declares the type of data accepted, using one or more
attributes that specify various aspects of the data URI (scheme, host,
port, path, etc.) and MIME type.
category : Declares the intent category accepted, in the name
attribute. The value must be the literal string value of an action,
not the class constant.
For example, This activity handles "SEND" actions with text data.
<intent-filter>
<action android:name="android.intent.action.SEND"/>
<category android:name="android.intent.category.DEFAULT"/>
<data android:mimeType="text/plain"/>
</intent-filter>

Intent filter tells the android system for which intent or event the android components(activity,service ,broadcast receiver) should listen.