You are here

Registry of intents protocols

Registry of Intent protocols.

This list describes intents that can be implemented by activities. Other application can use these intents and delegate the intent to these activities. (view in table format)

  • Split the screen to show two applications

    Action: 
    actiwerks.intent.splitview
    Status: 
    quasi standard
    Input: 
    Needs to have a single integer parameter, called APP_SPLIT_SIZE. This tells the underlying applications how much space at the top might be available.
    Output: 
    Underlying applications that are intercepting this Intent broadcast might have visible, as the application in the front made top of the screen transparent by moving down. The application on the background might try to adapt the UI to show some relevant information (subset of the normal UI) in the available space.

    See the open source reference implementation of both sender and receiver of the intent at : https://github.com/actiwerks/actionbarplus

    Video of the talk explaining the feature, presented at droidcon Berlin 2013, as well as the slides of the presentation can be seen there :
    http://de.droidcon.com/2013/sessnio/improving-android-experience-both-us...

    This Intent broadcast allows applications that conform to it to split the screen between two applications, in the way it is implemented on devices such as Samsung Galaxy Note, but in this case no modification to Android OS is necessary. The application in the front has a mechanism that allows it to reduce the screen estate it occupies, by "moving" the window downwards, and revealing the space on the top. The proposed gesture for this is implementing a custom ActionBar, that accepts two finger swipe down gesture. Such ActionBar would react by resizing window size.
    This gives underlying applications chance to "peek through" even if they are in the background, so some relevant information might be seen and used in the front application without switching the front and background applications.
    This can be useful for apps like references, where you can have the single token of information visible in a limited space.
    All that is needed is to implement Intent broadcast filter in case of the background application and the Intent broadcast for the application in the front when the two-finger swipe gesture is in a progress.

    Status of intents protocol: 
  • Bind to SSH Agent service

    Action: 
    org.openintents.ssh.BIND_SSH_AGENT_SERVICE
    Output: 
    IBinder for an instance of the AndroidAuthAgent AIDL interface. This interface allows the intent-invoking app to use the intent-serving app as an SSH-Agent.

    This intent is used to bind to a service which exposes the AndroidAuthAgent AIDL interface, allowing one app to use another as it's SSH agent.

    As part of the development of Agit (Git client for Android) I created a patch of ConnectBot which allows Agit, and other android apps, to use ConnectBot as an ssh-agent. This means that the client apps don't need to actually manage or even store SSH keys themselves, which is pretty cool. You only need to trust one app with your SSH keys - that's ConnectBot, which already has great infrastructure for managing public keys - and all other apps defer to it for signing the cryptographic-challenges required to initiate an SSH session. It works really well - it's a symphony of cryptography and inter-process communication!

    This is the bound interface, which the invoking-app can call when making an SSH connection in order to sign the cryptographic-challenges it receives (keys and signatures are OpenSSH-format encoded):

    https://github.com/rtyley/madgag-ssh/blob/master/ssh-android/src/main/ja...

    There's a pull-request ( https://github.com/kruton/connectbot/pull/13 ) to get this functionality merged back into ConnectBot, but unfortunately it looks like original version of ConnectBot is no longer maintained. I've distributed a patched version here:

    https://play.google.com/store/apps/details?id=com.madgag.ssh.agent

    The ssh-agent patch is also incorporated into this actively maintained fork of ConnectBot by Martin Matuška:

    https://play.google.com/store/apps/details?id=sk.vx.connectbot

    The invoking app will need the org.openintents.ssh.permission.ACCESS_SSH_AGENT permission to invoke the intent and bind to the ssh-agent.

    A simple demo implementation (as opposed to the much larger ConnectBot implementation) of an SSH-Agent app can be found here:

    https://github.com/rtyley/toy-android-ssh-agent

    Status of intents protocol: 
  • Pick directory

    Action: 
    org.openintents.action.PICK_DIRECTORY
    Input: 
    A file URI for suggested starting directory. Can also be left empty.
    Output: 
    File URI of the selected directory.

    Pick a directory (folder) through a file manager.

    Sample usage:

    Intent intent = new Intent("org.openintents.action.PICK_DIRECTORY");
    intent.setData(Uri.parseUri("file:///sdcard"));
    intent.putExtra("org.openintents.extra.TITLE", "Please select a folder");
    intent.putExtra("org.openintents.extra.BUTTON_TEXT", "Use this folder");
    startActivityForResult(intent, 1);

    The picked directory URI can be obtained in onActivityResult() through getData().

    Details can be found in the sample application TestFileManager in the public repository.

    You may want to use the OI File Manager intent definition file.

    Status of intents protocol: 
  • Edit Images with Photoshop.com Mobile 1.1 Editor

    Action: 
    android.intent.action.EDIT
    Input: 
    URI of the image to be edited,mime type of the image (must be of type “image/*”)
    Output: 
    The URI for the saved image

    Any application can use the Photoshop.com Mobile 1.1 editor for editing images on Android phones.

    For sample code and usage details, please visit
    http://mobile.photoshop.com/android/developers.html

    Status of intents protocol: 
  • Remote messaging

    Action: 
    com.xconns.peerdevicenet.SEND_MSG
    Input: 
    Extras: "MSG_DATA" - message content byte[] data "PEER_NAME"/"PEER_ADDR"/"PEER_PORT" - peer device info
    Output: 
    none

    PeerDeviceNet provides two sets of intents for remote messaging among peer devices:

    1. Intents for group communication:
    com.xconns.peerdevicenet.JOIN_GROUP
    com.xconns.peerdevicenet.LEAVE_GROUP
    com.xconns.peerdevicenet.SEND_MSG
    com.xconns.peerdevicenet.RECV_MSG
    com.xconns.peerdevicenet.PEER_JOIN
    com.xconns.peerdevicenet.PEER_LEAVE
    com.xconns.peerdevicenet.SELF_JOIN
    com.xconns.peerdevicenet.SELF_LEAVE

    2. Intents for setup device connections
    com.xconns.peerdevicenet.CONNECT
    com.xconns.peerdevicenet.DISCONNECT
    com.xconns.peerdevicenet.ACCEPT_CONNECTION
    com.xconns.peerdevicenet.DENY_CONNECTION
    com.xconns.peerdevicenet.CONNECTING
    com.xconns.peerdevicenet.CONNECTION_FAILED
    com.xconns.peerdevicenet.CONNECTED
    com.xconns.peerdevicenet.DISCONNECTED

    for more details, please refer to web site:
    http://www.peerdevicenet.net

    Status of intents protocol: 
  • Remote Intents

    Action: 
    com.xconns.peerdevicenet.START_REMOTE_ACTIVITY
    Input: 
    Extra: "REMOTE_INTENT" - the intent to be sent to peer "PEER_NAME"/"PEER_ADDR"/"PEER_PORT" - peer device info
    Output: 
    none

    PeerDeviceNet exposes a group of intents for sending intents to remote devices:

    com.xconns.peerdevicenet.START_REMOTE_ACTIVITY
    com.xconns.peerdevicenet.START_REMOTE_ACTIVITY_FOR_RESULT
    com.xconns.peerdevicenet.START_REMOTE_SERVICE
    com.xconns.peerdevicenet.SEND_REMOTE_BROADCAST

    for more details, please refer to
    http://www.peerdevicenet.net/rmt_intent.html

    Status of intents protocol: 
  • Send data to someone

    Action: 
    android.intent.action.SEND
    Action (WebIntents): 
    http://webintents.org/share
    Input: 
    type of the intent is the MIME type of the data being sent. get*Extra can have either a EXTRA_TEXT or EXTRA_STREAM field, containing the data to be sent. If using EXTRA_TEXT, the MIME type should be "text/plain"; otherwise it should be the MIME type of the data in EXTRA_STREAM. Use */* if the MIME type is unknown (this will only allow senders that can handle generic data streams). Optional standard extras, which may be interpreted by some recipients as appropriate, are: EXTRA_EMAIL, EXTRA_CC, EXTRA_BCC, EXTRA_SUBJECT.
    Output: 
    None

    Deliver some data to someone else.

    Who the data is being delivered to is not specified; it is up to the receiver of this action to ask the user where the data should be sent.

    This intent is described originally at http://code.google.com/android/reference/android/content/Intent.html#ACT...

    Status of intents protocol: 
  • Render pages of a PDF file

    Action: 
    com.acadoid.pdfview.action.RENDER_PAGES
    Input: 
    PDF file Uri page set resolution destination
    Output: 
    number of pages (and PDF file Uri for convenience)

    Input:
    - Uri of PDF file via Intent.putDataAndType() (should point to a file located on the SD card)
    - page set via Intent.putExtra("PAGE_SET", int[]) (pages are numbered 1 to number of pages, an empty page set results in all pages being rendered)
    - resolution via Intent.putExtra("RESOLUTION", float) (resolution to be understood in dpi, meaningful values range from 50 to 300 dpi)
    - destination via Intent.putExtra("DESTINATION", String) (pattern for PNG files to be created on the SD card, for instance `/mnt/sdcard/page%d.png´ where %d will be replaced by the page numbers given in the page set, not by consecutive numbers)
    Output:
    - number of pages via Intent.getExtras().getInt("PAGES") (the number is zero if a problem occurred)
    - Uri of PDF file via Intent.putDataAndType() (Uri of PDF file, mirrored for convenience)

    Status of intents protocol: 
  • Count pages of a PDF file

    Action: 
    com.acadoid.pdfview.action.COUNT_PAGES
    Input: 
    PDF file Uri
    Output: 
    number of pages (and PDF file Uri for convenience)

    counts the number of pages in a given PDF file
    Input:
    - Uri of PDF file via Intent.putDataAndType() (should point to a file located on the SD card)
    Output:
    - number of pages via Intent.getExtras().getInt("PAGES") (the number is zero if a problem occurred)
    - Uri of PDF file via Intent.putDataAndType() (Uri of PDF file, mirrored for convenience)

    Status of intents protocol: 
  • Browse File/Folder (Jump To)

    Action: 
    android.intent.action.VIEW
    Input: 
    A file/folder URI to start browsing as the Data and a Type of "vnd.android.cursor.item/file"
    Output: 
    None

    Open a file browser and display the file (or folder contents) of the File URI passed in. Also known as "Jump To..."

    Sample code:
    void browseFile(File aFile) {
    Intent theIntent = new Intent(Intent.ACTION_VIEW);
    //jump directly to the following file/folder
    Uri theFileUri = Uri.fromFile(aFile);
    theIntent.setDataAndType(theFileUri,"vnd.android.cursor.item/file");
    theIntent.putExtra(Intent.EXTRA_TITLE,"A Custom Title"); //optional
    try {
    startActivity(theIntent);
    } catch (Exception e) {
    e.printStackTrace();
    }
    }

    File Browsers/Managers wishing to implement this intent would use an AndroidManifest filter similar to:

    Status of intents protocol: 
  • Pick folder

    Action: 
    android.intent.action.PICK
    Input: 
    Scheme must be "folder". Data can be a file URI for suggested starting directory or can be left empty.
    Output: 
    File URI of the selected folder.

    Pick a folder through a file manager.

    android.intent.extra.TITLE could be used as well.
    Sample usage:

    Intent theIntent = new Intent(Intent.ACTION_PICK);
    theIntent.setData(Uri.parse("folder://"+aFolder.getPath())); //default folder / jump directly to this folder
    theIntent.putExtra(Intent.EXTRA_TITLE,"A Custom Title"); //optional
    startActivityForResult(theIntent, 1);

    The picked folder URI can be obtained in onActivityResult() through getData().

    Status of intents protocol: 
  • Web Intents "Discover" protocol

    Action: 
    org.openintents.DISCOVER

    The discover intent is designed to let the invoking Android components query services from the registered Web intents
    The "Discover" protocol is intended to be a lightweight registry list.

    Status of intents protocol: 
  • Launch of X server

    Action: 
    android.content.Intent.ACTION_VIEW
    Input: 
    Uri: x11://localhost:6000 where usually localhost is the bind address and 6000 means a port number ... An uri of x11://localhost:6100 would usually mean that the environment variable DISPLAY for the application would have been set to DISPLAY=localhost:100.
    Output: 
    An X server would be launched allowing other applications to use X11 protocol.

    This intention is used to allow X11 applications to be able to launch an X server as a prerrequisite for other applications.

    Status of intents protocol: 
  • Start GTalkSMS service and try to establish a connection.

    Action: 
    com.googlecode.gtalksms.action.CONNECT

    Starts the GTalkSMS service if its not already running and tries to establish a new connection.

    More information about GTalkSMS can be found at http://code.google.com/p/gtalksms/

    Status of intents protocol: 
  • Pick Color

    Action: 
    org.openintents.action.PICK_COLOR
    Input: 
    Optional: A default color
    Output: 
    The color chosen by the user.

    Pick a color using a color picker dialog.

    Applications should use startActivityForResult() to launch this color picker with a default color specified in the integer Intent extra "org.openintents.extra.COLOR". The chosen color will be returned in an Intent the same way.

    Status of intents protocol: 
  • Reserve/Book a table

    Action: 
    com.opentable.action.RESERVE
    Input: 
    URI defining the restaurant and party size in the format reserve://opentable.com/<locationID>?partySize=<party size>

    Reserve a table at a known location of opentable.com, partysize and refId are optional query parameters of the url.

    Read more at
    http://blog.7touchgroup.com/2009/12/integrating-application-with-intents/

    Status of intents protocol: 
  • launch matrix view of IP Cam Viewer

    Action: 
    android.intent.action.MAIN
    Input: 
    intent.addCategory( Intent.CATEGORY_LAUNCHER ); intent.setFlags( Intent.FLAG_ACTIVITY_NEW_TASK ); ComponentName cn = new ComponentName( "com.rcreations.WebCamViewerPaid", "com.rcreations.WebCamViewerPaid.IpCamViewerActivity" ); intent.setComponent( cn ); intent.putExtra( "selectView", "MATRIX_VIEW" );

    Launch the matrix view of the IP Cam Viewer application.

    For the free/Lite version, using the following component name instead:
    ComponentName cn = new ComponentName( "com.rcreations.ipcamviewer", "com.rcreations.ipcamviewer.WebCamViewerActivity" );

    For more info:
    http://hit-mob.com/forums/viewtopic.php?f=8&t=697

    Status of intents protocol: 
  • launch gallery view of IP Cam Viewer

    Action: 
    android.intent.action.MAIN
    Input: 
    intent.addCategory( Intent.CATEGORY_LAUNCHER ); intent.setFlags( Intent.FLAG_ACTIVITY_NEW_TASK ); ComponentName cn = new ComponentName( "com.rcreations.WebCamViewerPaid", "com.rcreations.WebCamViewerPaid.IpCamViewerActivity" ); intent.setComponent( cn ); intent.putExtra( "selectView", "GALLERY_VIEW" );

    Launch the gallery view of the IP Cam Viewer application.

    For the free/Lite version, using the following component name instead:
    ComponentName cn = new ComponentName( "com.rcreations.ipcamviewer", "com.rcreations.ipcamviewer.WebCamViewerActivity" );

    For more info:
    http://hit-mob.com/forums/viewtopic.php?f=8&t=697

    Status of intents protocol: 
  • Charting API TeeChart

    Action: 
    com.steema.teechart.android.CHART
    Input: 
    URI: "content:", "file:", "http:", "https:" MIME TYPE: "text/plain", "text/xml"
    Output: 
    Charts are created and returned to your Activity as Android Bitmap (PNG, JPEG) images.

    TeeChart CHART Intent enables your application creating charts without having to link the complete TeeChart API Java library.

    Data, text, formatting and styles can be submitted using the Intent putExtras method or in plain text or xml formats.

    final Intent intent = new Intent("com.steema.teechart.android.CHART");
    intent.setType("text/*");

    intent.putExtra("Header", "Hello World !");
    intent.putExtra("Style", "Bar");
    intent.putExtra("Text", new String[] { "A", "B", "C" });
    intent.putExtra("Values", new double[] { 45, 23, 12 });

    try {
    startActivityForResult(intent, 0);
    } catch (ActivityNotFoundException e) {
    ChartIntent.downloadTeeChart(this);
    }

    Status of intents protocol: 
  • Scan a QR code

    Action: 
    la.droid.qr.scan
    Input: 
    None
    Output: 
    Contents of QR code as String, under extra "la.droid.qr.result"

    Scan a QR code with QR Droid.

    Structure

    First, I’ll give a general idea of how QR Droid services are structured and how they must be called. To use QR Droid services, you must simply create an Intent with one of these actions:
    la.droid.qr.scan
    la.droid.qr.encode
    la.droid.qr.decode

    (Note that QR Droid package is “la.droid.qr“, so that’s why all actions have that prefix)

    You call one of this actions in 3 steps:
    Create a new Intent. For example: Intent qrDroid = new Intent( “la.droid.qr.scan” );
    Optionally, set any extra parameter: qrDroid.putExtra( “la.droid.qr.complete” , true);
    Finally, start activity and wait fo a result: startActivityForResult(qrDroid, 0);

    You must also override onActivityResult(int, int, Intent) to be able to receive result from QR Droid. Always, result is stored in data.getExtras().getString( “la.droid.qr.result” );

    When calling activity, you must consider that user could not have QR Droid nor QR Droid Private installed in his device. You can get a list of installed apps to check if QR Droid is one of them, or simply do something like this:

    try {
    startActivityForResult(qrDroid, ACTIVITY_RESULT_QR_DRDROID);
    } catch (ActivityNotFoundException activity) {
    //TODO: Ask user to get “QR Droid” or “QR Droid Private” from http://qrdroid.com/get
    }

    (Previous code is included in sample app, which you can download at bottom of this page)

    Scan Intent

    Action: To call Scan activity from QR Droid, you must create an Intent with action: la.droid.qr.scan

    Intent qrDroid = new Intent( “la.droid.qr.scan” );
    Optional parameter: This Activity has one optional parameter which specifies whether you want to receive full, unprocessed QR code contents; or only a visible, processed representation (this last one is default behavior). For example, a simple QR code with a phone number contains this “tel:+1234567“. By default, QR Droid will only send you back “+1234567″. If you want to receive full data (“tel:+1234567″), you must add this parameter:

    qrDroid.putExtra( “la.droid.qr.complete” , true);
    Call:

    startActivityForResult(qrDroid, 0);
    Result: Inside onActivityResult(int requestCode, int resultCode, Intent data), you must read result as String, like this:

    String result = data.getExtras().getString(“la.droid.qr.result”);

    Here, you can check out a little example of an Activity that calls QR Droid Scan service and reads content back.

    http://qrdroid.com/Scan.java

    It uses a few constants defined here: http://qrdroid.com/Services.java

    Status of intents protocol: 
  • Flashlight

    Action: 
    com.teslacoilsw.intent.FLASHLIGHT
    Input: 
    Optional extra: "on" (boolean) "timeout" (int) "off" (boolean) "toggle" (boolean) "strobe" (int [rate])

    Used to control the state of the LED Flash for flashlighting purposes.

    Supported in TeslaLED >= 2.0.1 (http://teslacoilsw.com/teslaled)

    Example usage:

    Intent intent = new Intent("com.teslacoilsw.intent.FLASHLIGHT");
    intent.putExtra("toggle", true);
    mContext.startService(intent);

    Or to start it for 5 minutes:

    Intent intent = new Intent("com.teslacoilsw.intent.FLASHLIGHT");
    intent.putExtra("on", true);
    intent.putExtra("timeout", 5);
    mContext.startService(intent);

    Or for when you're programming java at a rave:

    Intent intent = new Intent("com.teslacoilsw.intent.FLASHLIGHT");
    intent.putExtra("strobe", 10); /* 10 Hertz */
    mContext.startService(intent);

    Status of intents protocol: 
  • Save SIP Call

    Action: 
    de.ub0r.android.callmeter.SAVE_SIPCALL

    Send this broadcast to notify Call Meter 3G, that the call log entry (uri) is a SIP call done with the provider (provider).

    Status of intents protocol: 
  • Save WebSMS

    Action: 
    de.ub0r.android.callmeter.SAVE_WEBSMS

    Send the URI of a sent text message as broadcast to notify Call Meter 3G that the message was sent with the given WebSMS Connector.

    Status of intents protocol: 
  • Bluetooth Device Picker

    Action: 
    PICK_BLUETOOTH_DEVICE
    Output: 
    ADDR ( String ) - the MAC address FRIENDLYNAME ( String ) - the Name of the Device

    Let the user pick a Bluetooth Device. Returns MAC Address and Name.

    Status of intents protocol: 
  • Edit item

    Action: 
    net.lp.collectionista.action.EDIT_ITEM

    Edit an item specifically. An item from a collection.

    Originally for Collectionista, but every collection manager can use these.

    Status of intents protocol: 
  • Edit collection

    Action: 
    net.lp.collectionista.action.EDIT_COLLECTION

    Edit a collection specifically. A collection of items.

    Originally for Collectionista, but every collection manager can use these.

    Status of intents protocol: 
  • Edit name (of collections, items, ...)

    Action: 
    net.lp.collectionista.action.EDIT_NAME

    Edit the name of a collection or an item.

    Originally for Collectionista, but every collection manager can use these.

    Status of intents protocol: 
  • Playback Music

    Action: 
    com.mgeek.android.musicbox.PLAYBACK_VIEWER

    Shows a player, this is not really a protocol, maybe the author of the app can tell us more.

    Status of intents protocol: 
  • Big Red Button Pressed

    Action: 
    com.perseum.bigRedButtonPressed
    Input: 
    none
    Output: 
    none

    Notifies that the application "BigRedButton" has been pressed. This intent can be used by the End User for any purpose.

    Status of intents protocol: 
  • Audio Volume Update Notification Broadcast

    Action: 
    org.openintents.audio.action_volume_update
    Input: 
    Broadcast action: org.openintents.audio.action_volume_update Required Extra: org.openintents.audio.extra_stream_type Type of the stream upon which the volume is being changed, e.g. STREAM_MEDIA, STREAM_RING, etc. Required Extra: org.openintents.audio.extra_volume_index The volume level to which the stream is being set
    Output: 
    No output, the intent should be broadcast as an Ordered broadcast so that any receiver may have the option of cancelling the broadcast and aborting the volume change.

    This broadcast intent is used by an application to notify any receivers that an audio volume change is being performed.

    Use cases for this intent is for preventing any unauthorized or unintentional volume changes. For example, volume rockers can easily be hit changing the ringer volume from silent to audible; Ring Guard and Advanced Audio Manager use this intent to communicate volume changes such that RG will not prevent any volume changes made by AAM, but still protect against accidental rocker activation.

    Status of intents protocol: 
  • Pick an event

    Action: 
    android.intent.action.PICK
    Input: 
    Mandatory: supply a list of events with mime-type of "vnd.android.cursor.dir/event" and columns as follows: "_id": event id (long), "title": a string, "dtstart": the start time (long, milliseconds since Unix epoch), "calendar_id" (int)
    Output: 
    The id of the selected event and the date of that event.

    Pick an event using a calendar based interface. Also returns the event's date.

    Status of intents protocol: 
  • Pick a date

    Action: 
    android.intent.action.PICK
    Input: 
    Optionally supply a list of events with mime-type of "vnd.android.cursor.dir/event" and columns as follows: "_id": event id (long), "title": a string, "dtstart": the start time (long, milliseconds since Unix epoch), "calendar_id" (int)
    Output: 
    Either the id of the selected event or the date selected.

    Pick a date or event using a calendar based interface.

    Status of intents protocol: 
  • Environmental measurement

    Action: 
    com.borntotinker.intent.action.MEASURE
    Input: 
    Input the type of measurement to collect
    Output: 
    The result of the measurement collection will be returned. Units and data types will vary depending on the physical information being measured.

    An open ended intent to collect information from the android phone's surroundings.

    This could be physical information such as spatial measurement, acoustic decibel levels, ambient light levels, vibration sprectrum data, etc.

  • Print Image

    Action: 
    org.androidprinting.intent.action.PRINT
    Input: 
    URI of the image to be printed, mime type of the image (must be of type "image/*")

    Any application can use HP iPrint Photo for Android for printing images on nearby printers from Android phones.

    Status of intents protocol: 
  • Enter Habitat

    Action: 
    org.adaptroid.habitats.ACTION_ENTER_HABITAT

    Sticky broadcast intent sent by Habitats whenever the current habitat on an android device changes.

    Since the intent is sticky, a receiver can determine the current habitat by inspecting the extras in the intent returned by Context.registerReceiver. An integer identifier and a human readable name of the habitat are included as extras in the intent.

    Extras:
    org.adaptroid.habitats.HABITAT_ID
    An integer id for the new habitat.

    org.adaptroid.habitats.HABITAT_NAME
    A human readable name of the new habitat.

    Status of intents protocol: 
  • Color category

    Action: 
    org.openintents.category.COLOR
    Input: 
    An optional color.
    Output: 
    A color chosen by the user.

    Use as a <category> in combination with the Intent Action "android.intent.action.PICK" in order to launch a color picker.

    Status of intents protocol: 
  • User Info Chooser

    Action: 
    net.ivantis.userinfo.chooser
    Output: 
    net.ivantis.userinfo.settingId android.intent.extra.TEXT

    allows the user to choose information (username, password, email address..) to be filled into another application

    Status of intents protocol: 
  • Volume Control

    Action: 
    com.roozen.intent.VOLUME_CONTROL
    Input: 
    Integer: Key="TYPE", Value=Volume Stream (accepted values=AudioManager.STREAM_SYSTEM, AudioManager.STREAM_MUSIC, AudioManager.STREAM_RING, AudioManager.STREAM_VOICE_CALL, AudioManager.STREAM_ALARM, AudioManager.STREAM_NOTIFICATION)
    Output: 
    Currently None

    Use this intent to pop up a dialog box in your activity to allow the user to manually change one of the six volume streams as listed under input.

    This intent could be useful if an app is using several volume types (Alarms and Play Media, for example) and only provides the volume buttons to change volume for one type.

    (Category="android.intent.category.DEFAULT")

    Example Use:

    Intent intent = new Intent("com.roozen.intent.VOLUME_CONTROL");
    intent.addCategory(Intent.CATEGORY_DEFAULT);
    intent.putExtra("TYPE", AudioManager.STREAM_VOICE_CALL);
    startActivity(intent);

    How it Works: Opens dialog box of the specified volume type. User slides a progress bar to choose volume. The volume for that stream changes when the user slides the bar. When finished, the Android GUI for a volume change pops up to display the selected value. User touches OK button to close the dialog.

    If the volume type is System, Ringer, or Notification, a volume change will change the Ringmode to Normal (AudioManager.RING_MODE_NORMAL). This is because a change in volume will have no affect, as a user would expect it would, if the Ringmode is still Silent or Vibrate Only.

    Explanation of Streams:

    AudioManager.STREAM_MUSIC: For media, such as music and video.
    AudioManager.STREAM_ALARM: For Alarms.
    AudioManager.STREAM_VOICE_CALL: For In-Call Volume, that is, the volume of the other person's voice when in a call.
    AudioManager.STREAM_RING: For the ringer volume. Notifications are also on this stream unless the user deselects that option by going to (from home menu) Menu > Settings > Sound & display > Ringer Volume and deselecting the checkbox.
    AudioManager.STREAM_SYSTEM: For System volume, such as the sound of button presses, if that setting is turned on, or the camera shutter.
    AudioManager.STREAM_NOTIFICATION: Changes the volume for notification alerts.

    Status of intents protocol: 
  • Pay money

    Action: 
    org.openintents.action.PAYTO
    Input: 
    data uri specifying the receiver of the money
    Output: 
    none

    Intent to pay some one a specified amount of money.

    The receiver of the money could be specified by an email address (mailto://) or through content like "content://com.visa/savedreceivers/1", or mime type "text/x-bancAccount" or by additional information of a contact.

    Status of intents protocol: 
  • Show GPS Status

    Action: 
    com.eclipsim.gpsstatus.VIEW

    Shows the status of the GPS receiver, including the signal strength and location of visible satellites.

    The display grid is aligned using the built in compass. Additional info like location, speed, accuracy and acceleraion is also displayed. (only in GPS Status 1.4.2 and above)

    Status of intents protocol: 
  • Plot Data

    Action: 
    com.googlecode.chartdroid.intent.action.PLOT
    Input: 
    * int[] com.googlecode.chartdroid.intent.extra.DATA (required)<br/> * String[] com.googlecode.chartdroid.intent.extra.LABELS<br/> * int[] com.googlecode.chartdroid.intent.extra.COLORS (optional)<br/> * String com.googlecode.chartdroid.intent.extra.TITLE
    Output: 
    Chart representation of input data

    ChartDroid currently produces a pie chart representation of input data.

    More details:
    http://chartdroid.googlecode.com

    Status of intents protocol: 
  • Bluetooth Watch (Display text)

    Action: 
    com.smartmadsoft.openwatch.action

    Intents handled by OpenWatch. Any of these intents is capable displaying up to two lines of text.

    com.smartmadsoft.openwatch.action.ENVELOPE
    com.smartmadsoft.openwatch.action.TEXT
    com.smartmadsoft.openwatch.action.VIBRATE

    Status of intents protocol: 
  • Bluetooth Watch (Button press)

    Action: 
    com.smartmadsoft.openwatch.command

    Intents that are broadcasted on button press by OpenWatch (MBW-100, MBW-150, MBW-200).

    com.smartmadsoft.openwatch.command.BUTTON_FF
    com.smartmadsoft.openwatch.command.BUTTON_RW
    com.smartmadsoft.openwatch.command.BUTTON_PLAYPAUSE
    com.smartmadsoft.openwatch.command.BUTTON_VOLUME_UP
    com.smartmadsoft.openwatch.command.BUTTON_VOLUME_DOWN

    Status of intents protocol: 
  • Remote View

    Action: 
    org.openintents.remote.intent.action.VIEW

    Simulates an android.intent.action.VIEW intent on a remote machine.

    Although the remote machine may not be running Android, it may be controlled remotely by an Android application. For example, an Android application for controlling a media center may instruct the media center to open a file that is stored locally on the media center. The data URI would be interpreted relative to the remote machine. For example, a file:// URI would always refer to a file on the media center, not a file on the SD card of the device controlling the media center.

    An example of an application that would invoke this type of intent is a remote download manager. The download manager knows the file:// URI of the remote file and the hostname of the remote server, but does not know how to open the file remotely. The remote download manager can use this intent to see if any other applications installed on the device are able to open the file on the remote server.

    Complete example:

    Intent intent = new Intent("org.openintents.remote.intent.action.VIEW");
    intent.setDataAndType(Uri.parse("file:///home/user/video.mp4"), "video/mp4");
    intent.putExtra("org.openintents.remote.intent.extra.HOST", "mediacenter");
    startActivity(intent);

    Status of intents protocol: 
  • Record a new financial transaction

    Action: 
    com.funkyandroid.action.NEW_TRANSACTION
    Input: 
    The transaction details

    This intent reports a financial transaction to be recorded in an expenses or banking application.

    This is used, for example, by BistroMath to report the amount it has calculated for a persons tip to Funky Expenses for recording in the persons expenses account.

    It is recommended that the intent brings up a page which allows the user to confirm the transaction before it is recorded in order to prevent malicious applications filling an expenses/banking application with junk entries and to allow the user to fill in any missing information.

  • API for printing from Android Applications

    Action: 
    com.rcreations.send2printer.print
    Input: 
    URI: "content:", "file:", "http:", "https:" MIME TYPE: "text/plain", "text/html", "text/xml", "image/*", "application/x-android-picture-stream"
    Output: 
    content is rendered, queued, and then send to a network printer configured by the user.

    The "Send 2 Printer" application hooks into existing applications to enable printing,

    but you can also send the following data formats to Send 2 Printer for printing from your own applications:

    - HTML content
    - Text
    - Image
    - Canvas draw commands (via serialized Picture)
    - Canvas draw commands rendered to a Bitmap

    The following post contains sample code to print the above formats and include a sample "Test Print" eclipse project:

    http://hit-mob.com/forums/viewtopic.php?f=13&t=66

    More information about the "Send 2 Printer" application:

    http://hit-mob.com/forums/viewtopic.php?f=13&t=58

  • Translate

    Action: 
    org.openintents.action.TRANSLATE
    Input: 
    A Text to translate, the source language code and the target language code.
    Output: 
    The translated text.

    Translate a text

    Use some translation engine to translate a text and return the result.

  • Pick activity

    Action: 
    android.intent.action.PICK_ACTIVITY
    Input: 
    data should be empty.<br/> get*Extra field EXTRA_INTENT is an Intent used with queryIntentActivities(Intent, int) to determine the set of activities from which to pick.
    Output: 
    Class name of the activity that was selected.

    Pick an activity given an intent, returning the class selected.

    See Android documentation

    Example: Pick an application

    // Pick an application
    Intent mainIntent = new Intent(Intent.ACTION_MAIN, null);
    mainIntent.addCategory(Intent.CATEGORY_LAUNCHER);
     
    Intent pickIntent = new Intent(Intent.ACTION_PICK_ACTIVITY);
    pickIntent.putExtra(Intent.EXTRA_INTENT, mainIntent);
    startActivityForResult(pickIntent, 0);
     
    // The result is obtained in onActivityResult:
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
       if (data != null) {
          // launch the application that we just picked
          startActivity(data);
       }
    }

    Note: The PICK_ACTIVITY intent only works in SDK 1.5 or higher. In SDK 1.1 this code does not work.
    A backward compatible implementation of the activity picker can be found in the source code of the OI Locale bridge.

  • Ringmode Control

    Action: 
    com.roozen.intent.RINGMODE_CONTROL
    Input: 
    None
    Output: 
    None

    Brings user to activity to quickly change the phone's ringmode.

    Example Usage:

    Intent intent = new Intent("com.roozen.intent.RINGMODE_CONTROL");
    intent.addCategory(Intent.CATEGORY_DEFAULT);
    startActivity(intent);

  • Vibration Control

    Action: 
    com.roozen.intent.VIBRATION_CONTROL
    Input: 
    None
    Output: 
    None

    Brings user to activity to quickly change the phone's vibration settings.

    Example Usage:

    Intent intent = new Intent("com.roozen.intent.VIBRATION_CONTROL");
    intent.addCategory(Intent.CATEGORY_DEFAULT);
    startActivity(intent);

  • Sound Control

    Action: 
    com.roozen.intent.SOUND_CONTROL
    Input: 
    None
    Output: 
    None

    Brings user to a sound control screen where user can modify a number of different sound settings.

    Example Usage:

    Intent intent = new Intent("com.roozen.intent.SOUND_CONTROL");
    intent.addCategory(Intent.CATEGORY_DEFAULT);
    startActivity(intent);

  • Pick file

    Action: 
    org.openintents.action.PICK_FILE
    Input: 
    A file URI for suggested file name or starting directory. Can also be left empty.
    Output: 
    File URI of the selected file.

    Pick a file through a file manager.

    Sample usage:

    Intent intent = new Intent("org.openintents.action.PICK_FILE");
    intent.setData(Uri.parseUri("file:///sdcard/notepad.csv"));
    intent.putExtra("org.openintents.extra.TITLE", "Please select a file");
    startActivityForResult(intent, 1);

    The picked file URI can be obtained in onActivityResult() through getData().

    Details can be found in the sample application TestFileManager in the public repository, that can be also downloaded from OI download page.

    You may want to use the OI File Manager intent definition file.

  • Calculator

    Action: 
    org.openintents.action.CALCULATOR
    Input: 
    Intent extras: "X" optional initial double value "Y" optional initial secondary double value "Z" optional initial tertiary double value
    Output: 
    Intent extras: "X" double value "Y" optional secondary double value "Z" optional tertiary double value

    Launches a calculator, returns the final value calculated by the user. See RpnCalc for an example of an app that responds to this intent.

  • Show about dialog

    Action: 
    org.openintents.action.SHOW_ABOUT_DIALOG

    Show an about dialog to display information about your application.

    By default the information is retrieved from the Manifest of your application (both from the manifest tag as from metadata tags). Metadata keys are specified in (as constants) in org.openintents.metadata.AboutMetaData. Optionally send along extras with information to display (overriding the metadata). Intent extra keys are specified (as constants) in org.openintents.intents.AboutIntents.

    From your "about" menu option you start an activity with this specific intent action:

    Intent intent = new Intent("org.openintents.action.SHOW_ABOUT_DIALOG");
    startActivityForResult(intent, 0);

    The activity needs to be launched "forResult" with requestCode>=0 so that the package name is passed properly. Optionally, one can set the intent extra org.openintents.extra.PACKAGE_NAME.

    Original use is with OI About: See OI About for usage information for this intent.
    An OI TestAboutApp demonstrating this is also available.

  • Send Twitter Message

    Action: 
    com.twidroid.SendTweet

    Send a Twitter/Identi.ca Message thru Twidroid.


    Intent intent = new Intent("com.twidroid.SendTweet");
    intent.putExtra("com.twidroid.extra.MESSAGE",
    "This is a test from Twidroid public intent.");
    startActivityForResult(intent, 1);

    See complete code sample on Snipplr

  • Call

    Action: 
    android.intent.action.CALL
    Input: 
    If nothing, an empty dialer is started; else getData() is URI of a phone number to be dialed or a tel: URI of an explicit phone number.

    Perform a call to someone specified by the data.

    Note: there will be restrictions on which applications can initiate a call; most applications should use the ACTION_DIAL.

    Note: this Intent cannot be used to call emergency numbers. Applications can dial emergency numbers using ACTION_DIAL, however.

    Calls the entered phone number. Valid telephone numbers as defined in the IETF RFC 3966 are accepted. Valid examples include the following:

    • tel:2125551212
    • tel: (212) 555 1212

    The dialer is good at normalizing some kinds of schemes: for example telephone numbers, so the schema described isn't strictly required in the Uri(URI string) factory. However, if you have not tried a schema or are unsure whether it can be handled, use the Uri.fromParts(scheme, ssp, fragment) factory instead.

    Note:   This requires your application to request the following permission in your manifest: <uses-permission id="android.permission.CALL_PHONE" />

    See Android documentation, Available intents

  • Web search

    Action: 
    android.intent.action.WEB_SEARCH
    Input: 
    getData() is URI of data. If it is a URL that starts with http or https, the site will be opened. If it is plain text, Google search will be applied.
    Output: 
    nothing

    Perform a web search.

    Opens the file at the location on the device in the browser. If the data is plain text, Google search will be applied.

    See Android documentation

  • Check for Update

    Action: 
    org.openintents.intents.CHECK_VERSION
    Input: 
    data: url to version info file

    Preliminary protocol until Market improves update facitilities!

    data describes an url to a simple text file containing information about the latest version or a VeeCheck file. If a new version is available the user is notified and can initiate the update process.

  • Scan

    Action: 
    com.google.zxing.client.android.SCAN

    Scan a barcode.

    Send this intent to open the Barcodes app in scanning mode, find a barcode, and return the results.

    By default, sending Scan.ACTION will decode all barcodes that we understand. However it may be useful to limit scanning to certain formats. Use Intent.putExtra("SCAN_MODE", value) with one of the values below (optional).

    • PRODUCT_MODE: Decode only UPC and EAN barcodes. This is the right choice for shopping apps which get prices, reviews, etc. for products.
    • ONE_D_MODE: Decode only 1D barcodes (currently UPC, EAN, Code 39, and Code 128).
    • QR_CODE_MODE: Decode only QR codes.

    If a barcode is found, Barcodes returns RESULT_OK to onActivityResult() of the app which requested the scan via startSubActivity(). The barcodes contents can be retrieved with intent.getStringExtra("SCAN_RESULT"). If the user presses Back, the result code will be RESULT_CANCELED.

    See Android Manifest, com.google.zxing.client.android.Intents, and com.google.zxing.client.android.Contents

  • Encode

    Action: 
    com.google.zxing.client.android.ENCODE

    Encode to barcode and display on screen.

    Send this intent to encode a piece of data as a QR code and display it full screen, so that another person can scan the barcode from your screen.

    Use Intent.putExtra("ENCODE_DATA", data) where data is either a String or a Bundle, depending on the type specified. See Contents for details. Use Intent.putExtra("ENCODE_TYPE", type) with one of Contents.Type.

    See Android Manifest, com.google.zxing.client.android.Intents, and com.google.zxing.client.android.Contents

  • Search book contents

    Action: 
    com.google.zxing.client.android.SEARCH_BOOK_CONTENTS

    Use Google Book Search to search the contents of the book provided.

    Intent specific extras:

    • ISBN: The book to search, identified by ISBN number.
    • QUERY: An optional field which is the text to search for.

    See Android Manifest and com.google.zxing.client.android.Intents.

  • Share (through QR code)

    Action: 
    com.google.zxing.client.android.SHARE

    Display an item as QR code to scan with a phone.

    Give the user a choice of items to encode as a barcode, then render it as a QR Code and display onscreen for a friend to scan with their phone.

  • Capture an image

    Action: 
    android.media.action.IMAGE_CAPTURE
    Input: 
    none

    An application implementing this intent protocol allows the user to capture an image.

  • Send a message to the given uri

    Action: 
    android.intent.action.SENDTO
    Input: 
    data is the URI describing the target.
    Output: 
    None

    Send a message to someone specified by the data.

  • Record sound

    Action: 
    android.provider.MediaStore.RECORD_SOUND
    Input: 
    None.
    Output: 
    An uri to the recorded sound stored in the Media Library if the recording was successful.

    Start SoundRecorder application to record sound.

    More info: Android documentation.

  • Flickr photo

    Action: 
    com.google.android.photostream.FLICKR_PHOTO

    Show a flickr photo.

    Blog: Photostream.

    Shows an individual photo from Flickr.

  • Flickr stream

    Action: 
    com.google.android.photostream.FLICKR_STREAM

    Display a Flickr stream.

    See Photostream.

    Either the NSID or the user name can be provided as extra.

  • Connect host

    Action: 
    org.theb.ssh.action.CONNECT_HOST
    Input: 
    Content URI of the host to connect to.

    Connect to a host.

    This intent is defined for Connectbot.

  • Resolve unresolved intents

    Action: 
    org.openintents.intents.UNRESOLVED_INTENT
    Input: 
    none
    Output: 
    none

    Delegates the user to a selection of possible applications that can resolve the given intent.

  • List all applications

    Action: 
    android.intent.action.ALL_APPS
    Input: 
    None
    Output: 
    None

    List all available applications.

    Activities implementing this intent show a list of all available applications.

    See Android documentation.

  • Ringtone picker

    Action: 
    android.intent.action.RINGTONE_PICKER

    Show a ringtone picker.

    Use this intent to show a ringtone picker to the user.

    See Android documentation.

  • Tag data

    Action: 
    org.openintents.action.TAG
    Input: 
    content uri of tag
    Output: 
    None

    Add a tag to the given data.

    Activity implementing this intent provide means to add the given tag or newly entered tag to the given data.

    The data is specified by its content URI.

  • Edit title

    Action: 
    com.android.notepad.action.EDIT_TITLE
    Input: 
    URI of the content whose title should be edited.
    Output: 
    None.

    Edit the title of a content.

    See Notepad example.

    It is a custom action defined for the Notepad application.

  • Dial a number

    Action: 
    android.intent.action.DIAL
    Input: 
    If nothing, an empty dialer is started; else URI of a phone number to be dialed.
    Output: 
    None

    Dial a number as specified by the data.

    This shows a UI with the number being dialed, allowing the user to explicitly initiate the call.

    The uri can be a tel: URI of an explicit phone number.

    See Android documentation.

  • Delete data

    Action: 
    android.intent.action.DELETE
    Input: 
    URI of data to be deleted.
    Output: 
    None

    Delete the given data from its container.

    Activity implementing this intent delete the given data from its container.

    See Android documentation.

  • Edit data

    Action: 
    android.intent.action.EDIT
    Input: 
    URI of the data to be edited.
    Output: 
    None

    Provide explicit editable access to the given data.

    Activity implementing this intent provides explicit editable access to the given data.

    See Android documentation.

  • Set wallpaper

    Action: 
    android.intent.action.SET_WALLPAPER
    Input: 
    None.
    Output: 
    None.

    Show settings for choosing wallpaper

    See Android documentation.

    This lets one choose a background for the home screen.

  • Create shortcut

    Action: 
    android.intent.action.CREATE_SHORTCUT
    Input: 
    None.
    Output: 
    An Intent representing the shortcut.

    Creates a shortcut on the main screen.

    See Android documentation.

  • Search

    Action: 
    android.intent.action.SEARCH
    Input: 
    None
    Output: 
    None

    Perform a search.

    see Android documentation.

    getStringExtra(SearchManager.QUERY) is the text to search for. If empty, simply enter your search results Activity with the search UI activated.

  • Get content

    Action: 
    android.intent.action.GET_CONTENT
    Input: 
    The desired MIME type to retrieve.
    Output: 
    The URI of the item that was picked.

    Allow the user to select a particular kind of data and return it.

    see Android documentation

    This is different than ACTION_PICK in that here we just say what kind of data is desired, not a URI of existing data from which the user can pick. A ACTION_GET_CONTENT could allow the user to create the data as it runs (for example taking a picture or recording a sound), let them browser over the web and download the desired data, etc.

    There are two main ways to use this action: if you want an specific kind of data, such as a person contact, you set the MIME type to the kind of data you want and launch it with startActivity(Intent). The system will then launch the best application to select that kind of data for you.

    You may also be interested in any of a set of types of content the user can pick. For example, an e-mail application that wants to allow the user to add an attachment to an e-mail message can use this action to bring up a list of all of the types of content the user can attach.

    In this case, you should wrap the GET_CONTENT intent with a chooser (through createChooser(Intent, CharSequence)), which will give the proper interface for the user to pick how to send your data and allow you to specify a prompt indicating what they are doing. You will usually specify a broad MIME type (such as image/* or */*), resulting in a broad range of content types the user can select from.

    When using such a broad GET_CONTENT action, it is often desireable to only pick from data that can be represented as a stream. This is accomplished by requiring the CATEGORY_OPENABLE in the Intent.

    Input: getType() is the desired MIME type to retrieve. Note that no URI is supplied in the intent, as there are no constraints on where the returned data originally comes from. You may also include the CATEGORY_OPENABLE if you can only accept data that can be opened as a stream.

    Output: The URI of the item that was picked. This must be a content: URI so that any receiver can access it.

  • View data

    Action: 
    android.intent.action.VIEW
    Input: 
    Uri of the data to be displayed
    Output: 
    None

    Display the data to the user.

    An activity implementing this action will display to the user the
    given data. It is not intended for the user to edit it, though an
    implementation can allow that to be done as a secondary part of its UI
    if desired (as it can provide any other optional features in its UI
    for the user).

    This is the most common action performed on data -- it is the generic action you can use on a piece of data to get the most reasonable thing to occur. For example, when used on a contacts entry it will view the entry; when used on a mailto: URI it will bring up a compose window filled with the information supplied by the URI; when used with a tel: URI it will invoke the dialer.

    See Android documentation

  • Main

    Action: 
    android.intent.action.MAIN
    Input: 
    None
    Output: 
    None

    Start as a main entry point, does not expect to receive data.

    See Android documentation

  • Insert data

    Action: 
    android.intent.action.INSERT
    Input: 
    URI of the directory (vnd.android.cursor.dir/*) in which to place the data.
    Output: 
    URI of the new data that was created.

    Insert an empty item into the given container.

    See Android reference.

  • Pick data

    Action: 
    android.intent.action.PICK
    Input: 
    URI containing a directory of data (vnd.android.cursor.dir/*) from which to pick an item.
    Output: 
    The URI of the item that was picked.

    Pick an item from the data, returning what was selected.

    see Android documentation

  • Show radar

    Action: 
    com.google.android.radar.SHOW_RADAR
    Input: 
    None
    Output: 
    None

    Display a radar like view centered around the current position and mark the given location