• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2006 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package android.provider;
18 
19 import android.content.ContentResolver;
20 import android.content.ContentUris;
21 import android.content.ContentValues;
22 import android.content.Context;
23 import android.content.Intent;
24 import android.database.Cursor;
25 import android.database.DatabaseUtils;
26 import android.graphics.BitmapFactory;
27 import android.net.Uri;
28 import android.provider.BrowserContract.Bookmarks;
29 import android.provider.BrowserContract.Combined;
30 import android.provider.BrowserContract.History;
31 import android.provider.BrowserContract.Searches;
32 import android.util.Log;
33 import android.webkit.WebIconDatabase;
34 
35 public class Browser {
36     private static final String LOGTAG = "browser";
37 
38     /**
39      * A table containing both bookmarks and history items. The columns of the table are defined in
40      * {@link BookmarkColumns}. Reading this table requires the
41      * {@link android.Manifest.permission#READ_HISTORY_BOOKMARKS} permission and writing to it
42      * requires the {@link android.Manifest.permission#WRITE_HISTORY_BOOKMARKS} permission.
43      */
44     public static final Uri BOOKMARKS_URI = Uri.parse("content://browser/bookmarks");
45 
46     /**
47      * The name of extra data when starting Browser with ACTION_VIEW or
48      * ACTION_SEARCH intent.
49      * <p>
50      * The value should be an integer between 0 and 1000. If not set or set to
51      * 0, the Browser will use default. If set to 100, the Browser will start
52      * with 100%.
53      */
54     public static final String INITIAL_ZOOM_LEVEL = "browser.initialZoomLevel";
55 
56     /**
57      * The name of the extra data when starting the Browser from another
58      * application.
59      * <p>
60      * The value is a unique identification string that will be used to
61      * identify the calling application. The Browser will attempt to reuse the
62      * same window each time the application launches the Browser with the same
63      * identifier.
64      */
65     public static final String EXTRA_APPLICATION_ID = "com.android.browser.application_id";
66 
67     /**
68      * The name of the extra data in the VIEW intent. The data are key/value
69      * pairs in the format of Bundle. They will be sent in the HTTP request
70      * headers for the provided url. The keys can't be the standard HTTP headers
71      * as they are set by the WebView. The url's schema must be http(s).
72      * <p>
73      */
74     public static final String EXTRA_HEADERS = "com.android.browser.headers";
75 
76     /* if you change column order you must also change indices
77        below */
78     public static final String[] HISTORY_PROJECTION = new String[] {
79             BookmarkColumns._ID, // 0
80             BookmarkColumns.URL, // 1
81             BookmarkColumns.VISITS, // 2
82             BookmarkColumns.DATE, // 3
83             BookmarkColumns.BOOKMARK, // 4
84             BookmarkColumns.TITLE, // 5
85             BookmarkColumns.FAVICON, // 6
86             BookmarkColumns.THUMBNAIL, // 7
87             BookmarkColumns.TOUCH_ICON, // 8
88             BookmarkColumns.USER_ENTERED, // 9
89     };
90 
91     /* these indices dependent on HISTORY_PROJECTION */
92     public static final int HISTORY_PROJECTION_ID_INDEX = 0;
93     public static final int HISTORY_PROJECTION_URL_INDEX = 1;
94     public static final int HISTORY_PROJECTION_VISITS_INDEX = 2;
95     public static final int HISTORY_PROJECTION_DATE_INDEX = 3;
96     public static final int HISTORY_PROJECTION_BOOKMARK_INDEX = 4;
97     public static final int HISTORY_PROJECTION_TITLE_INDEX = 5;
98     public static final int HISTORY_PROJECTION_FAVICON_INDEX = 6;
99     /**
100      * @hide
101      */
102     public static final int HISTORY_PROJECTION_THUMBNAIL_INDEX = 7;
103     /**
104      * @hide
105      */
106     public static final int HISTORY_PROJECTION_TOUCH_ICON_INDEX = 8;
107 
108     /* columns needed to determine whether to truncate history */
109     public static final String[] TRUNCATE_HISTORY_PROJECTION = new String[] {
110             BookmarkColumns._ID,
111             BookmarkColumns.DATE,
112     };
113 
114     public static final int TRUNCATE_HISTORY_PROJECTION_ID_INDEX = 0;
115 
116     /* truncate this many history items at a time */
117     public static final int TRUNCATE_N_OLDEST = 5;
118 
119     /**
120      * A table containing a log of browser searches. The columns of the table are defined in
121      * {@link SearchColumns}. Reading this table requires the
122      * {@link android.Manifest.permission#READ_HISTORY_BOOKMARKS} permission and writing to it
123      * requires the {@link android.Manifest.permission#WRITE_HISTORY_BOOKMARKS} permission.
124      */
125     public static final Uri SEARCHES_URI = Uri.parse("content://browser/searches");
126 
127     /**
128      * A projection of {@link #SEARCHES_URI} that contains {@link SearchColumns#_ID},
129      * {@link SearchColumns#SEARCH}, and {@link SearchColumns#DATE}.
130      */
131     public static final String[] SEARCHES_PROJECTION = new String[] {
132             // if you change column order you must also change indices below
133             SearchColumns._ID, // 0
134             SearchColumns.SEARCH, // 1
135             SearchColumns.DATE, // 2
136     };
137 
138     /* these indices dependent on SEARCHES_PROJECTION */
139     public static final int SEARCHES_PROJECTION_SEARCH_INDEX = 1;
140     public static final int SEARCHES_PROJECTION_DATE_INDEX = 2;
141 
142     /* Set a cap on the count of history items in the history/bookmark
143        table, to prevent db and layout operations from dragging to a
144        crawl.  Revisit this cap when/if db/layout performance
145        improvements are made.  Note: this does not affect bookmark
146        entries -- if the user wants more bookmarks than the cap, they
147        get them. */
148     private static final int MAX_HISTORY_COUNT = 250;
149 
150     /**
151      *  Open an activity to save a bookmark. Launch with a title
152      *  and/or a url, both of which can be edited by the user before saving.
153      *
154      *  @param c        Context used to launch the activity to add a bookmark.
155      *  @param title    Title for the bookmark. Can be null or empty string.
156      *  @param url      Url for the bookmark. Can be null or empty string.
157      */
saveBookmark(Context c, String title, String url)158     public static final void saveBookmark(Context c,
159                                           String title,
160                                           String url) {
161         Intent i = new Intent(Intent.ACTION_INSERT, Browser.BOOKMARKS_URI);
162         i.putExtra("title", title);
163         i.putExtra("url", url);
164         c.startActivity(i);
165     }
166 
167     /**
168      * Boolean extra passed along with an Intent to a browser, specifying that
169      * a new tab be created.  Overrides EXTRA_APPLICATION_ID; if both are set,
170      * a new tab will be used, rather than using the same one.
171      */
172     public static final String EXTRA_CREATE_NEW_TAB = "create_new_tab";
173 
174     /**
175      * Stores a Bitmap extra in an {@link Intent} representing the screenshot of
176      * a page to share.  When receiving an {@link Intent#ACTION_SEND} from the
177      * Browser, use this to access the screenshot.
178      * @hide
179      */
180     public final static String EXTRA_SHARE_SCREENSHOT = "share_screenshot";
181 
182     /**
183      * Stores a Bitmap extra in an {@link Intent} representing the favicon of a
184      * page to share.  When receiving an {@link Intent#ACTION_SEND} from the
185      * Browser, use this to access the favicon.
186      * @hide
187      */
188     public final static String EXTRA_SHARE_FAVICON = "share_favicon";
189 
190     /**
191      * Sends the given string using an Intent with {@link Intent#ACTION_SEND} and a mime type
192      * of text/plain. The string is put into {@link Intent#EXTRA_TEXT}.
193      *
194      * @param context the context used to start the activity
195      * @param string the string to send
196      */
sendString(Context context, String string)197     public static final void sendString(Context context, String string) {
198         sendString(context, string, context.getString(com.android.internal.R.string.sendText));
199     }
200 
201     /**
202      *  Find an application to handle the given string and, if found, invoke
203      *  it with the given string as a parameter.
204      *  @param c Context used to launch the new activity.
205      *  @param stringToSend The string to be handled.
206      *  @param chooserDialogTitle The title of the dialog that allows the user
207      *  to select between multiple applications that are all capable of handling
208      *  the string.
209      *  @hide pending API council approval
210      */
sendString(Context c, String stringToSend, String chooserDialogTitle)211     public static final void sendString(Context c,
212                                         String stringToSend,
213                                         String chooserDialogTitle) {
214         Intent send = new Intent(Intent.ACTION_SEND);
215         send.setType("text/plain");
216         send.putExtra(Intent.EXTRA_TEXT, stringToSend);
217 
218         try {
219             Intent i = Intent.createChooser(send, chooserDialogTitle);
220             // In case this is called from outside an Activity
221             i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
222             c.startActivity(i);
223         } catch(android.content.ActivityNotFoundException ex) {
224             // if no app handles it, do nothing
225         }
226     }
227 
228     /**
229      *  Return a cursor pointing to a list of all the bookmarks. The cursor will have a single
230      *  column, {@link BookmarkColumns#URL}.
231      *  <p>
232      *  Requires {@link android.Manifest.permission#READ_HISTORY_BOOKMARKS}
233      *
234      *  @param cr   The ContentResolver used to access the database.
235      */
getAllBookmarks(ContentResolver cr)236     public static final Cursor getAllBookmarks(ContentResolver cr) throws
237             IllegalStateException {
238         return cr.query(Bookmarks.CONTENT_URI,
239                 new String[] { Bookmarks.URL },
240                 Bookmarks.IS_FOLDER + " = 0", null, null);
241     }
242 
243     /**
244      *  Return a cursor pointing to a list of all visited site urls. The cursor will
245      *  have a single column, {@link BookmarkColumns#URL}.
246      *  <p>
247      *  Requires {@link android.Manifest.permission#READ_HISTORY_BOOKMARKS}
248      *
249      *  @param cr   The ContentResolver used to access the database.
250      */
getAllVisitedUrls(ContentResolver cr)251     public static final Cursor getAllVisitedUrls(ContentResolver cr) throws
252             IllegalStateException {
253         return cr.query(Combined.CONTENT_URI,
254                 new String[] { Combined.URL }, null, null,
255                 Combined.DATE_CREATED + " ASC");
256     }
257 
addOrUrlEquals(StringBuilder sb)258     private static final void addOrUrlEquals(StringBuilder sb) {
259         sb.append(" OR " + BookmarkColumns.URL + " = ");
260     }
261 
getVisitedLike(ContentResolver cr, String url)262     private static final Cursor getVisitedLike(ContentResolver cr, String url) {
263         boolean secure = false;
264         String compareString = url;
265         if (compareString.startsWith("http://")) {
266             compareString = compareString.substring(7);
267         } else if (compareString.startsWith("https://")) {
268             compareString = compareString.substring(8);
269             secure = true;
270         }
271         if (compareString.startsWith("www.")) {
272             compareString = compareString.substring(4);
273         }
274         StringBuilder whereClause = null;
275         if (secure) {
276             whereClause = new StringBuilder(Bookmarks.URL + " = ");
277             DatabaseUtils.appendEscapedSQLString(whereClause,
278                     "https://" + compareString);
279             addOrUrlEquals(whereClause);
280             DatabaseUtils.appendEscapedSQLString(whereClause,
281                     "https://www." + compareString);
282         } else {
283             whereClause = new StringBuilder(Bookmarks.URL + " = ");
284             DatabaseUtils.appendEscapedSQLString(whereClause,
285                     compareString);
286             addOrUrlEquals(whereClause);
287             String wwwString = "www." + compareString;
288             DatabaseUtils.appendEscapedSQLString(whereClause,
289                     wwwString);
290             addOrUrlEquals(whereClause);
291             DatabaseUtils.appendEscapedSQLString(whereClause,
292                     "http://" + compareString);
293             addOrUrlEquals(whereClause);
294             DatabaseUtils.appendEscapedSQLString(whereClause,
295                     "http://" + wwwString);
296         }
297         return cr.query(History.CONTENT_URI, new String[] { History._ID, History.VISITS },
298                 whereClause.toString(), null, null);
299     }
300 
301     /**
302      *  Update the visited history to acknowledge that a site has been
303      *  visited.
304      *  Requires {@link android.Manifest.permission#READ_HISTORY_BOOKMARKS}
305      *  Requires {@link android.Manifest.permission#WRITE_HISTORY_BOOKMARKS}
306      *  @param cr   The ContentResolver used to access the database.
307      *  @param url  The site being visited.
308      *  @param real If true, this is an actual visit, and should add to the
309      *              number of visits.  If false, the user entered it manually.
310      */
updateVisitedHistory(ContentResolver cr, String url, boolean real)311     public static final void updateVisitedHistory(ContentResolver cr,
312                                                   String url, boolean real) {
313         long now = System.currentTimeMillis();
314         Cursor c = null;
315         try {
316             c = getVisitedLike(cr, url);
317             /* We should only get one answer that is exactly the same. */
318             if (c.moveToFirst()) {
319                 ContentValues values = new ContentValues();
320                 if (real) {
321                     values.put(History.VISITS, c.getInt(1) + 1);
322                 } else {
323                     values.put(History.USER_ENTERED, 1);
324                 }
325                 values.put(History.DATE_LAST_VISITED, now);
326                 cr.update(ContentUris.withAppendedId(History.CONTENT_URI, c.getLong(0)),
327                         values, null, null);
328             } else {
329                 truncateHistory(cr);
330                 ContentValues values = new ContentValues();
331                 int visits;
332                 int user_entered;
333                 if (real) {
334                     visits = 1;
335                     user_entered = 0;
336                 } else {
337                     visits = 0;
338                     user_entered = 1;
339                 }
340                 values.put(History.URL, url);
341                 values.put(History.VISITS, visits);
342                 values.put(History.DATE_LAST_VISITED, now);
343                 values.put(History.TITLE, url);
344                 values.put(History.DATE_CREATED, 0);
345                 values.put(History.USER_ENTERED, user_entered);
346                 cr.insert(History.CONTENT_URI, values);
347             }
348         } catch (IllegalStateException e) {
349             Log.e(LOGTAG, "updateVisitedHistory", e);
350         } finally {
351             if (c != null) c.close();
352         }
353     }
354 
355     /**
356      *  Returns all the URLs in the history.
357      *  Requires {@link android.Manifest.permission#READ_HISTORY_BOOKMARKS}
358      *  @param cr   The ContentResolver used to access the database.
359      *  @hide pending API council approval
360      */
getVisitedHistory(ContentResolver cr)361     public static final String[] getVisitedHistory(ContentResolver cr) {
362         Cursor c = null;
363         String[] str = null;
364         try {
365             String[] projection = new String[] {
366                     History.URL,
367             };
368             c = cr.query(History.CONTENT_URI, projection, History.VISITS + " > 0", null, null);
369             if (c == null) return new String[0];
370             str = new String[c.getCount()];
371             int i = 0;
372             while (c.moveToNext()) {
373                 str[i] = c.getString(0);
374                 i++;
375             }
376         } catch (IllegalStateException e) {
377             Log.e(LOGTAG, "getVisitedHistory", e);
378             str = new String[0];
379         } finally {
380             if (c != null) c.close();
381         }
382         return str;
383     }
384 
385     /**
386      * If there are more than MAX_HISTORY_COUNT non-bookmark history
387      * items in the bookmark/history table, delete TRUNCATE_N_OLDEST
388      * of them.  This is used to keep our history table to a
389      * reasonable size.  Note: it does not prune bookmarks.  If the
390      * user wants 1000 bookmarks, the user gets 1000 bookmarks.
391      *  Requires {@link android.Manifest.permission#READ_HISTORY_BOOKMARKS}
392      *  Requires {@link android.Manifest.permission#WRITE_HISTORY_BOOKMARKS}
393      *
394      * @param cr The ContentResolver used to access the database.
395      */
truncateHistory(ContentResolver cr)396     public static final void truncateHistory(ContentResolver cr) {
397         // TODO make a single request to the provider to do this in a single transaction
398         Cursor cursor = null;
399         try {
400 
401             // Select non-bookmark history, ordered by date
402             cursor = cr.query(History.CONTENT_URI,
403                     new String[] { History._ID, History.URL, History.DATE_LAST_VISITED },
404                     null, null, History.DATE_LAST_VISITED + " ASC");
405 
406             if (cursor.moveToFirst() && cursor.getCount() >= MAX_HISTORY_COUNT) {
407                 final WebIconDatabase iconDb = WebIconDatabase.getInstance();
408                 /* eliminate oldest history items */
409                 for (int i = 0; i < TRUNCATE_N_OLDEST; i++) {
410                     cr.delete(ContentUris.withAppendedId(History.CONTENT_URI, cursor.getLong(0)),
411                             null, null);
412                     iconDb.releaseIconForPageUrl(cursor.getString(1));
413                     if (!cursor.moveToNext()) break;
414                 }
415             }
416         } catch (IllegalStateException e) {
417             Log.e(LOGTAG, "truncateHistory", e);
418         } finally {
419             if (cursor != null) cursor.close();
420         }
421     }
422 
423     /**
424      * Returns whether there is any history to clear.
425      *  Requires {@link android.Manifest.permission#READ_HISTORY_BOOKMARKS}
426      * @param cr   The ContentResolver used to access the database.
427      * @return boolean  True if the history can be cleared.
428      */
canClearHistory(ContentResolver cr)429     public static final boolean canClearHistory(ContentResolver cr) {
430         Cursor cursor = null;
431         boolean ret = false;
432         try {
433             cursor = cr.query(History.CONTENT_URI,
434                 new String [] { History._ID, History.VISITS },
435                 null, null, null);
436             ret = cursor.getCount() > 0;
437         } catch (IllegalStateException e) {
438             Log.e(LOGTAG, "canClearHistory", e);
439         } finally {
440             if (cursor != null) cursor.close();
441         }
442         return ret;
443     }
444 
445     /**
446      *  Delete all entries from the bookmarks/history table which are
447      *  not bookmarks.  Also set all visited bookmarks to unvisited.
448      *  Requires {@link android.Manifest.permission#WRITE_HISTORY_BOOKMARKS}
449      *  @param cr   The ContentResolver used to access the database.
450      */
clearHistory(ContentResolver cr)451     public static final void clearHistory(ContentResolver cr) {
452         deleteHistoryWhere(cr, null);
453     }
454 
455     /**
456      * Helper function to delete all history items and release the icons for them in the
457      * {@link WebIconDatabase}.
458      *
459      * Requires {@link android.Manifest.permission#READ_HISTORY_BOOKMARKS}
460      * Requires {@link android.Manifest.permission#WRITE_HISTORY_BOOKMARKS}
461      *
462      * @param cr   The ContentResolver used to access the database.
463      * @param whereClause   String to limit the items affected.
464      *                      null means all items.
465      */
deleteHistoryWhere(ContentResolver cr, String whereClause)466     private static final void deleteHistoryWhere(ContentResolver cr, String whereClause) {
467         Cursor cursor = null;
468         try {
469             cursor = cr.query(History.CONTENT_URI, new String[] { History.URL }, whereClause,
470                     null, null);
471             if (cursor.moveToFirst()) {
472                 final WebIconDatabase iconDb = WebIconDatabase.getInstance();
473                 do {
474                     // Delete favicons
475                     // TODO don't release if the URL is bookmarked
476                     iconDb.releaseIconForPageUrl(cursor.getString(0));
477                 } while (cursor.moveToNext());
478 
479                 cr.delete(History.CONTENT_URI, whereClause, null);
480             }
481         } catch (IllegalStateException e) {
482             Log.e(LOGTAG, "deleteHistoryWhere", e);
483             return;
484         } finally {
485             if (cursor != null) cursor.close();
486         }
487     }
488 
489     /**
490      * Delete all history items from begin to end.
491      *  Requires {@link android.Manifest.permission#WRITE_HISTORY_BOOKMARKS}
492      * @param cr    The ContentResolver used to access the database.
493      * @param begin First date to remove.  If -1, all dates before end.
494      *              Inclusive.
495      * @param end   Last date to remove. If -1, all dates after begin.
496      *              Non-inclusive.
497      */
deleteHistoryTimeFrame(ContentResolver cr, long begin, long end)498     public static final void deleteHistoryTimeFrame(ContentResolver cr,
499             long begin, long end) {
500         String whereClause;
501         String date = BookmarkColumns.DATE;
502         if (-1 == begin) {
503             if (-1 == end) {
504                 clearHistory(cr);
505                 return;
506             }
507             whereClause = date + " < " + Long.toString(end);
508         } else if (-1 == end) {
509             whereClause = date + " >= " + Long.toString(begin);
510         } else {
511             whereClause = date + " >= " + Long.toString(begin) + " AND " + date
512                     + " < " + Long.toString(end);
513         }
514         deleteHistoryWhere(cr, whereClause);
515     }
516 
517     /**
518      * Remove a specific url from the history database.
519      *  Requires {@link android.Manifest.permission#WRITE_HISTORY_BOOKMARKS}
520      * @param cr    The ContentResolver used to access the database.
521      * @param url   url to remove.
522      */
deleteFromHistory(ContentResolver cr, String url)523     public static final void deleteFromHistory(ContentResolver cr,
524                                                String url) {
525         cr.delete(History.CONTENT_URI, History.URL + "=?", new String[] { url });
526     }
527 
528     /**
529      * Add a search string to the searches database.
530      *  Requires {@link android.Manifest.permission#READ_HISTORY_BOOKMARKS}
531      *  Requires {@link android.Manifest.permission#WRITE_HISTORY_BOOKMARKS}
532      * @param cr   The ContentResolver used to access the database.
533      * @param search    The string to add to the searches database.
534      */
addSearchUrl(ContentResolver cr, String search)535     public static final void addSearchUrl(ContentResolver cr, String search) {
536         // The content provider will take care of updating existing searches instead of duplicating
537         ContentValues values = new ContentValues();
538         values.put(Searches.SEARCH, search);
539         values.put(Searches.DATE, System.currentTimeMillis());
540         cr.insert(Searches.CONTENT_URI, values);
541     }
542 
543     /**
544      * Remove all searches from the search database.
545      *  Requires {@link android.Manifest.permission#WRITE_HISTORY_BOOKMARKS}
546      * @param cr   The ContentResolver used to access the database.
547      */
clearSearches(ContentResolver cr)548     public static final void clearSearches(ContentResolver cr) {
549         // FIXME: Should this clear the urls to which these searches lead?
550         // (i.e. remove google.com/query= blah blah blah)
551         try {
552             cr.delete(Searches.CONTENT_URI, null, null);
553         } catch (IllegalStateException e) {
554             Log.e(LOGTAG, "clearSearches", e);
555         }
556     }
557 
558     /**
559      *  Request all icons from the database.  This call must either be called
560      *  in the main thread or have had Looper.prepare() invoked in the calling
561      *  thread.
562      *  Requires {@link android.Manifest.permission#READ_HISTORY_BOOKMARKS}
563      *  @param  cr The ContentResolver used to access the database.
564      *  @param  where Clause to be used to limit the query from the database.
565      *          Must be an allowable string to be passed into a database query.
566      *  @param  listener IconListener that gets the icons once they are
567      *          retrieved.
568      */
requestAllIcons(ContentResolver cr, String where, WebIconDatabase.IconListener listener)569     public static final void requestAllIcons(ContentResolver cr, String where,
570             WebIconDatabase.IconListener listener) {
571         WebIconDatabase.getInstance().bulkRequestIconForPageUrl(cr, where, listener);
572     }
573 
574     /**
575      * Column definitions for the mixed bookmark and history items available
576      * at {@link #BOOKMARKS_URI}.
577      */
578     public static class BookmarkColumns implements BaseColumns {
579         /**
580          * The URL of the bookmark or history item.
581          * <p>Type: TEXT (URL)</p>
582          */
583         public static final String URL = "url";
584 
585         /**
586          * The number of time the item has been visited.
587          * <p>Type: NUMBER</p>
588          */
589         public static final String VISITS = "visits";
590 
591         /**
592          * The date the item was last visited, in milliseconds since the epoch.
593          * <p>Type: NUMBER (date in milliseconds since January 1, 1970)</p>
594          */
595         public static final String DATE = "date";
596 
597         /**
598          * Flag indicating that an item is a bookmark. A value of 1 indicates a bookmark, a value
599          * of 0 indicates a history item.
600          * <p>Type: INTEGER (boolean)</p>
601          */
602         public static final String BOOKMARK = "bookmark";
603 
604         /**
605          * The user visible title of the bookmark or history item.
606          * <p>Type: TEXT</p>
607          */
608         public static final String TITLE = "title";
609 
610         /**
611          * The date the item created, in milliseconds since the epoch.
612          * <p>Type: NUMBER (date in milliseconds since January 1, 1970)</p>
613          */
614         public static final String CREATED = "created";
615 
616         /**
617          * The favicon of the bookmark. Must decode via {@link BitmapFactory#decodeByteArray}.
618          * <p>Type: BLOB (image)</p>
619          */
620         public static final String FAVICON = "favicon";
621 
622         /**
623          * @hide
624          */
625         public static final String THUMBNAIL = "thumbnail";
626 
627         /**
628          * @hide
629          */
630         public static final String TOUCH_ICON = "touch_icon";
631 
632         /**
633          * @hide
634          */
635         public static final String USER_ENTERED = "user_entered";
636     }
637 
638     /**
639      * Column definitions for the search history table, available at {@link #SEARCHES_URI}.
640      */
641     public static class SearchColumns implements BaseColumns {
642         /**
643          * @deprecated Not used.
644          */
645         @Deprecated
646         public static final String URL = "url";
647 
648         /**
649          * The user entered search term.
650          */
651         public static final String SEARCH = "search";
652 
653         /**
654          * The date the search was performed, in milliseconds since the epoch.
655          * <p>Type: NUMBER (date in milliseconds since January 1, 1970)</p>
656          */
657         public static final String DATE = "date";
658     }
659 }
660