page.title=Search Overview
@jd:body

<div id="qv-wrapper">
<div id="qv">
<h2>Topics</h2>
<ol>
<li><a href="search-dialog.html">Creating a Search Interface</a></li>
<li><a href="adding-recent-query-suggestions.html">Adding Recent Query Suggestions</a></li>
<li><a href="adding-custom-suggestions.html">Adding Custom Suggestions</a></li>
</ol>
<h2>Reference</h2>
<ol>
<li><a href="searchable-config.html">Searchable Configuration</a></li>
</ol>
<h2>Related samples</h2>
<ol>
<li><a href="{@docRoot}resources/samples/SearchableDictionary/index.html">Searchable
Dictionary</a></li>
</ol>
</div>
</div>


<p>Search is a core user feature on Android. Users should be able
to search any data that is available to them, whether the content is located on the device or
the Internet. To help create a consistent search experience for users, Android provides a
search framework that helps you implement search for your application.</p>

<div class="figure" style="width:250px">
<img src="{@docRoot}images/search/search-suggest-custom.png" alt="" height="417" />
<p class="img-caption"><strong>Figure 1.</strong> Screenshot of a search dialog with custom
search suggestions.</p>
</div>

<p>The search framework offers two modes of search input: a search dialog at the top of the
screen or a search widget ({@link android.widget.SearchView}) that you can embed in your activity
layout. In either case, the Android system will assist your search implementation by
delivering search queries to a specific activity that performs searchs. You can also enable either
the search dialog or widget to provide search suggestions as the user types. Figure 1 shows an
example of the search dialog with optional search suggestions.</p>

<p>Once you've set up either the search dialog or the search widget, you can:</p>

<ul>
<li>Enable voice search</li>
<li>Provide search suggestions based on recent user queries</li>
<li>Provide custom search suggestions that match actual results in your application data</li>
<li>Offer your application's search suggestions in the system-wide Quick Search Box</li>
</ul>

<p class="note"><strong>Note</strong>: The search framework does <em>not</em> provide APIs to
search your data. To perform a search, you need to use APIs appropriate for your data. For example,
if your data is stored in an SQLite database, you should use the {@link android.database.sqlite}
APIs to perform searches.
<br/><br/>
Also, there is no guarantee that a device provides a dedicated SEARCH button that invokes the
search interface in your application. When using the search dialog or a custom interface, you
must provide a search button in your UI that activates the search interface. For more
information, see <a href="search-dialog.html#InvokingTheSearchDialog">Invoking the search
dialog</a>.</p>

<p>The following documents show you how to use Android's framework to implement search:</p>

<dl>
  <dt><strong><a href="search-dialog.html">Creating a Search Interface</a></strong></dt>
  <dd>How to set up your application to use the search dialog or search widget. </dd>
  <dt><strong><a href="adding-recent-query-suggestions.html">Adding Recent Query
Suggestions</a></strong></dt>
  <dd>How to provide suggestions based on queries previously used.</dd>
  <dt><strong><a href="adding-custom-suggestions.html">Adding Custom Suggestions</a></strong></dt>
  <dd>How to provide suggestions based on custom data from your application and also offer them
in the system-wide Quick Search Box.</dd>
  <dt><strong><a href="searchable-config.html">Searchable Configuration</a></strong></dt>
  <dd>A reference document for the searchable configuration file (though the other
documents also discuss the configuration file in terms of specific behaviors).</dd>
</dl>


<h2>Protecting User Privacy</h2>

<p>When you implement search in your application, take steps to protect the user's
privacy. Many users consider their activities on the phone&mdash;including searches&mdash;to
be private information. To protect each user's privacy, you should abide by the following
principles:</p>

<ul>
<li><strong>Don't send personal information to servers, but if you must, do not log it.</strong>
<p>Personal information is any information that can personally identify your users, such as their
names, email addresses, billing information, or other data that can be reasonably linked to such
information. If your application implements search with the assistance of a server, avoid sending
personal information along with the search queries. For example, if you are searching for businesses
near a zip code,
you don't need to send the user ID as well; send only the zip code to the server. If you must
send the personal information, you should not log it. If you must log it, protect that data
very carefully and erase it as soon as possible.</p>
</li>
<li><strong>Provide users with a way to clear their search history.</strong>
<p>The search framework helps your application provide context-specific suggestions while the user
types. Sometimes these
suggestions are based on previous searches or other actions taken by the user in an earlier
session. A user might not wish for previous searches to be revealed to other device users, for
instance, if the user shares the device with a friend. If your application provides suggestions that
can reveal previous search activities, you should implement the ability for the user to clear the
search history. If you are using {@link android.provider.SearchRecentSuggestions}, you can simply
call the {@link android.provider.SearchRecentSuggestions#clearHistory()} method. If you are
implementing custom suggestions, you'll need to provide a similar "clear history" method in your
content provider that the user can execute.</p>
</li>
</ul>


