Java Code Examples for android.content.ContentResolver

@Override protected Uri create(){
  Uri uri=super.create();
  if (uri != null) {
    ContentResolver cr=getContentResolver();
    ArrayList<Integer> reminderMinutes=reminderItemsToMinutes(mReminderItems,mReminderValues);
    long taskId=ContentUris.parseId(uri);
    saveReminders(cr,taskId,reminderMinutes,mOriginalMinutes);
  }
  return uri;
}
 

public Hints(Context context,SharedPreferences prefs,Display display){
  mContext=context;
  mPrefs=prefs;
  mDisplay=display;
  ContentResolver cr=mContext.getContentResolver();
  mSwipeHintMaxDaysToShow=SettingsUtil.getSettingsInt(cr,SettingsUtil.LATIN_IME_VOICE_INPUT_SWIPE_HINT_MAX_DAYS,DEFAULT_SWIPE_HINT_MAX_DAYS_TO_SHOW);
  mPunctuationHintMaxDisplays=SettingsUtil.getSettingsInt(cr,SettingsUtil.LATIN_IME_VOICE_INPUT_PUNCTUATION_HINT_MAX_DISPLAYS,DEFAULT_PUNCTUATION_HINT_MAX_DISPLAYS);
}
 

/** 
 * Marks a specific message thread as read - all messages in the thread will be marked read
 */
public static void setThreadRead(Context context,long threadId){
  boolean markRead=false;
  if (!markRead)   return;
  if (threadId > 0) {
    ContentValues values=new ContentValues(1);
    values.put("read",READ_THREAD);
    ContentResolver cr=context.getContentResolver();
    try {
      cr.update(ContentUris.withAppendedId(CONVERSATION_CONTENT_URI,threadId),values,null,null);
    }
 catch (    Exception e) {
    }
  }
}
 

private void setSelectedApnKey(String key){
  mSelectedKey=key;
  ContentResolver resolver=getContentResolver();
  ContentValues values=new ContentValues();
  values.put(APN_ID,mSelectedKey);
  resolver.update(PREFERAPN_URI,values,null,null);
}
 

/** 
 * Unregister all CalendarObserver's
 */
static public void unregisterCalendarObservers(){
  ExchangeService exchangeService=INSTANCE;
  if (exchangeService == null)   return;
  ContentResolver resolver=exchangeService.mResolver;
  for (  CalendarObserver observer : exchangeService.mCalendarObservers.values()) {
    resolver.unregisterContentObserver(observer);
  }
  exchangeService.mCalendarObservers.clear();
}
 

private void checkScanning(){
  ContentResolver cr=getContentResolver();
  final boolean scanning=ImageManager.isMediaScannerScanning(cr);
  mHandler.post(new Runnable(){
    public void run(){
      checkScanningFinished(scanning);
    }
  }
);
}
 

public LocalImage(Path path,GalleryApp application,int id){
  super(path,nextVersionNumber());
  mApplication=application;
  ContentResolver resolver=mApplication.getContentResolver();
  Uri uri=Images.Media.EXTERNAL_CONTENT_URI;
  Cursor cursor=LocalAlbum.getItemCursor(resolver,uri,PROJECTION,id);
  if (cursor == null) {
    throw new RuntimeException("cannot get cursor for: " + path);
  }
  try {
    if (cursor.moveToNext()) {
      loadFromCursor(cursor);
    }
 else {
      throw new RuntimeException("cannot find data for: " + path);
    }
  }
  finally {
    cursor.close();
  }
}
 

public void finish(){
  ContentResolver cr=getContext().getContentResolver();
  if (albumsChanged) {
    cr.notifyChange(ALBUMS_URI,null,false);
  }
  if (photosChanged) {
    cr.notifyChange(PHOTOS_URI,null,false);
  }
  albumsChanged=false;
  photosChanged=false;
}
 

void registerForAirplaneMode(IntentFilter filter){
  final ContentResolver resolver=mContext.getContentResolver();
  final String airplaneModeRadios=Settings.System.getString(resolver,Settings.System.AIRPLANE_MODE_RADIOS);
  final String toggleableRadios=Settings.System.getString(resolver,Settings.System.AIRPLANE_MODE_TOGGLEABLE_RADIOS);
  mIsAirplaneSensitive=airplaneModeRadios == null ? true : airplaneModeRadios.contains(Settings.System.RADIO_NFC);
  mIsAirplaneToggleable=toggleableRadios == null ? false : toggleableRadios.contains(Settings.System.RADIO_NFC);
  if (mIsAirplaneSensitive) {
    filter.addAction(Intent.ACTION_AIRPLANE_MODE_CHANGED);
  }
}
 

@Override public void run(){
  final ContentValues emptyContentValues=new ContentValues();
  final ContentResolver resolver=getContentResolver();
  mCursor.moveToPosition(-1);
  while (!mCanceled && mCursor.moveToNext()) {
    actuallyImportOneSimContact(mCursor,resolver,mAccount);
    mProgressDialog.incrementProgressBy(1);
  }
  mProgressDialog.dismiss();
  finish();
}
 

private void doToggle(){
  ContentResolver cr=getActivity().getContentResolver();
  Uri uri=Uri.withAppendedPath(Apps.CONTENT_URI,String.valueOf(mShownIndex));
  ContentValues values=new ContentValues();
  values.put(Apps.ALLOW,mAllow == 1 ? 0 : 1);
  cr.update(uri,values,null,null);
  values.clear();
  values.put(Logs.DATE,System.currentTimeMillis());
  values.put(Logs.TYPE,Logs.LogType.TOGGLE);
  cr.insert(Uri.withAppendedPath(Logs.CONTENT_URI,String.valueOf(mShownIndex)),values);
  Intent intent=new Intent(getActivity(),ResultService.class);
  intent.putExtra(ResultService.EXTRA_ACTION,ResultService.ACTION_RECYCLE);
  getActivity().startService(intent);
}
 

public Hints(Context context,SharedPreferences prefs,Display display){
  mContext=context;
  mPrefs=prefs;
  mDisplay=display;
  ContentResolver cr=mContext.getContentResolver();
  mSwipeHintMaxDaysToShow=SettingsUtil.getSettingsInt(cr,SettingsUtil.LATIN_IME_VOICE_INPUT_SWIPE_HINT_MAX_DAYS,DEFAULT_SWIPE_HINT_MAX_DAYS_TO_SHOW);
  mPunctuationHintMaxDisplays=SettingsUtil.getSettingsInt(cr,SettingsUtil.LATIN_IME_VOICE_INPUT_PUNCTUATION_HINT_MAX_DISPLAYS,DEFAULT_PUNCTUATION_HINT_MAX_DISPLAYS);
}
 

protected void loadDictionaryAsync(){
  Cursor cursor=getWordsCursor();
  addWords(cursor);
  cursor.close();
  ContentResolver cres=mContext.getContentResolver();
  cres.registerContentObserver(Words.CONTENT_URI,true,mObserver=new ContentObserver(null){
    @Override public void onChange(    boolean self){
      mRequiresReload=true;
    }
  }
);
}
 

/** 
 * @return the uri of the newly installed ringtone
 */
private static Uri installSoundFile(File soundFile,String name){
  ContentValues values=new ContentValues();
  values.put(MediaStore.MediaColumns.DATA,soundFile.getAbsolutePath());
  values.put(MediaStore.MediaColumns.TITLE,name);
  values.put(MediaStore.MediaColumns.MIME_TYPE,"audio/ogg");
  values.put(MediaStore.MediaColumns.SIZE,soundFile.length());
  values.put(MediaStore.Audio.Media.ARTIST,"AlarmApp");
  values.put(MediaStore.Audio.Media.IS_RINGTONE,false);
  values.put(MediaStore.Audio.Media.IS_NOTIFICATION,false);
  values.put(MediaStore.Audio.Media.IS_ALARM,true);
  values.put(MediaStore.Audio.Media.IS_MUSIC,false);
  Uri uri=MediaStore.Audio.Media.getContentUriForPath(soundFile.getAbsolutePath());
  ContentResolver mCr=AlarmApp.getInstance().getContentResolver();
  Uri contentUri=mCr.insert(uri,values);
  LogEx.verbose("Installed Ringtone uri is " + contentUri);
  return Uri.parse(soundFile.getAbsolutePath());
}
 

/** 
 * Called when the activity is first created. 
 */
@Override public void onCreate(Bundle savedInstanceState){
  super.onCreate(savedInstanceState);
  setContentView(R.layout.main);
  Intent intent=getIntent();
  Bundle extras=intent.getExtras();
  String action=intent.getAction();
  if (Intent.ACTION_SEND.equals(action)) {
    if (extras.containsKey(Intent.EXTRA_STREAM)) {
      try {
        Uri uri=(Uri)extras.getParcelable(Intent.EXTRA_STREAM);
        ContentResolver cr=getContentResolver();
        InputStream is=cr.openInputStream(uri);
        byte[] data=getBytesFromFile(is);
        byte[] encoded_data=Base64.encodeBase64(data);
        String data_string=new String(encoded_data);
        SendRequest(data_string);
        return;
      }
 catch (      Exception e) {
        Log.e(this.getClass().getName(),e.toString());
      }
    }
 else     if (extras.containsKey(Intent.EXTRA_TEXT)) {
      return;
    }
  }
}
 

/** 
 * Synchronize raw contacts
 * @param context The context of Authenticator Activity
 * @param account The username for the account
 * @param users The list of users
 */
public static synchronized void syncContacts(Context context,String account,List<User> users){
  long userId;
  long rawContactId=0;
  final ContentResolver resolver=context.getContentResolver();
  final BatchOperation batchOperation=new BatchOperation(context,resolver);
  Log.d(TAG,"In SyncContacts");
  for (  final User user : users) {
    userId=user.getUserId();
    rawContactId=lookupRawContact(resolver,userId);
    if (rawContactId != 0) {
      if (!user.isDeleted()) {
        updateContact(context,resolver,account,user,rawContactId,batchOperation);
      }
 else {
        deleteContact(context,rawContactId,batchOperation);
      }
    }
 else {
      Log.d(TAG,"In addContact");
      if (!user.isDeleted()) {
        addContact(context,account,user,batchOperation);
      }
    }
    if (batchOperation.size() >= 50) {
      batchOperation.execute();
    }
  }
  batchOperation.execute();
}
 

public Integer doInBackground(Void... params){
  int imported=0;
  try {
    if (mBooks == null)     mBooks=ImportUtilities.loadItems();
    final List<String> list=mBooks;
    final BooksStore booksStore=BookStoreFactory.get(ShelvesActivity.this);
    final int count=list.size();
    final ContentResolver resolver=mResolver;
    final AtomicInteger importCount=mImportCount;
    for (int i=importCount.get(); i < count; i++) {
      publishProgress(i,count);
      if (isCancelled())       return null;
      final String id=list.get(i);
      if (!BooksManager.bookExists(mResolver,id)) {
        if (isCancelled())         return null;
        BooksStore.Book book=BooksManager.loadAndAddBook(resolver,id,booksStore);
        if (book != null) {
          if (Config.LOGD) {
            android.util.Log.d(LOG_TAG,book.toString());
          }
          imported++;
        }
      }
      importCount.incrementAndGet();
    }
  }
 catch (  IOException e) {
    return null;
  }
  return imported;
}
 

@Override public void onCreate(Bundle savedInstanceState){
  super.onCreate(savedInstanceState);
  setTitle(R.string.backlight_title);
  addPreferencesFromResource(R.xml.backlight_settings);
  PreferenceScreen prefSet=getPreferenceScreen();
  ContentResolver cr=getContentResolver();
  mFilterEnabled=(CheckBoxPreference)prefSet.findPreference(FILTER_ENABLED);
  mFilterEnabled.setChecked(Settings.System.getInt(cr,Settings.System.LIGHT_FILTER,0) != 0);
  mFilterEnabled.setOnPreferenceChangeListener(this);
  mFilterReset=(ListPreference)prefSet.findPreference(FILTER_RESET);
  mFilterReset.setValue(String.valueOf(Settings.System.getInt(cr,Settings.System.LIGHT_FILTER_RESET,-1)));
  mFilterReset.setOnPreferenceChangeListener(this);
  mFilterWindow=(ListPreference)prefSet.findPreference(FILTER_WINDOW);
  mFilterWindow.setValue(String.valueOf(Settings.System.getInt(cr,Settings.System.LIGHT_FILTER_WINDOW,30000)));
  mFilterWindow.setOnPreferenceChangeListener(this);
  mFilterInterval=(ListPreference)prefSet.findPreference(FILTER_INTERVAL);
  mFilterInterval.setValue(String.valueOf(Settings.System.getInt(cr,Settings.System.LIGHT_FILTER_INTERVAL,1000)));
  mFilterInterval.setOnPreferenceChangeListener(this);
  mLevelsEnabled=(CheckBoxPreference)prefSet.findPreference(LEVELS_ENABLED);
  mLevelsEnabled.setChecked(Settings.System.getInt(cr,Settings.System.LIGHT_SENSOR_CUSTOM,0) != 0);
  mLevelsEnabled.setOnPreferenceChangeListener(this);
  mScreenDim=(ListPreference)prefSet.findPreference(SCREEN_DIM);
  mScreenDim.setValue(String.valueOf(Settings.System.getInt(cr,Settings.System.LIGHT_SCREEN_DIM,android.os.Power.BRIGHTNESS_DIM)));
  mScreenDim.setOnPreferenceChangeListener(this);
  mDecreaseEnabled=(CheckBoxPreference)prefSet.findPreference(DECREASE_ENABLED);
  mDecreaseEnabled.setChecked(Settings.System.getInt(cr,Settings.System.LIGHT_DECREASE,0) != 0);
  mDecreaseEnabled.setOnPreferenceChangeListener(this);
  mDecreaseHysteresis=(ListPreference)prefSet.findPreference(DECREASE_HYSTERESIS);
  mDecreaseHysteresis.setValue(String.valueOf(Settings.System.getInt(cr,Settings.System.LIGHT_HYSTERESIS,50)));
  mDecreaseHysteresis.setOnPreferenceChangeListener(this);
}
 

@Override public void onCreate(Bundle savedInstanceState){
  super.onCreate(savedInstanceState);
  addPreferencesFromResource(R.xml.backlight_settings);
  PreferenceScreen prefSet=getPreferenceScreen();
  ContentResolver cr=getContentResolver();
  mFilterEnabled=(CheckBoxPreference)prefSet.findPreference(FILTER_ENABLED);
  mFilterEnabled.setChecked(Settings.System.getInt(cr,Settings.System.LIGHT_FILTER,0) != 0);
  mFilterEnabled.setOnPreferenceChangeListener(this);
  mFilterReset=(ListPreference)prefSet.findPreference(FILTER_RESET);
  mFilterReset.setValue(String.valueOf(Settings.System.getInt(cr,Settings.System.LIGHT_FILTER_RESET,-1)));
  mFilterReset.setOnPreferenceChangeListener(this);
  mFilterWindow=(ListPreference)prefSet.findPreference(FILTER_WINDOW);
  mFilterWindow.setValue(String.valueOf(Settings.System.getInt(cr,Settings.System.LIGHT_FILTER_WINDOW,30000)));
  mFilterWindow.setOnPreferenceChangeListener(this);
  mFilterInterval=(ListPreference)prefSet.findPreference(FILTER_INTERVAL);
  mFilterInterval.setValue(String.valueOf(Settings.System.getInt(cr,Settings.System.LIGHT_FILTER_INTERVAL,1000)));
  mFilterInterval.setOnPreferenceChangeListener(this);
  mLevelsEnabled=(CheckBoxPreference)prefSet.findPreference(LEVELS_ENABLED);
  mLevelsEnabled.setChecked(Settings.System.getInt(cr,Settings.System.LIGHT_SENSOR_CUSTOM,0) != 0);
  mLevelsEnabled.setOnPreferenceChangeListener(this);
  mScreenDim=(ListPreference)prefSet.findPreference(SCREEN_DIM);
  mScreenDim.setValue(String.valueOf(Settings.System.getInt(cr,Settings.System.LIGHT_SCREEN_DIM,android.os.Power.BRIGHTNESS_DIM)));
  mScreenDim.setOnPreferenceChangeListener(this);
  mDecreaseEnabled=(CheckBoxPreference)prefSet.findPreference(DECREASE_ENABLED);
  mDecreaseEnabled.setChecked(Settings.System.getInt(cr,Settings.System.LIGHT_DECREASE,0) != 0);
  mDecreaseEnabled.setOnPreferenceChangeListener(this);
  mDecreaseHysteresis=(ListPreference)prefSet.findPreference(DECREASE_HYSTERESIS);
  mDecreaseHysteresis.setValue(String.valueOf(Settings.System.getInt(cr,Settings.System.LIGHT_HYSTERESIS,50)));
  mDecreaseHysteresis.setOnPreferenceChangeListener(this);
}
 

public boolean isAutoSyncEnabled(){
  if (android.os.Build.VERSION.SDK_INT >= 5) {
    Class<ContentResolver> contentResolverClass=ContentResolver.class;
    try {
      Method m=contentResolverClass.getMethod("getMasterSyncAutomatically",null);
      Log.d(TAG,m.toString());
      Log.d(TAG,m.invoke(null,null).toString());
      boolean bool=((Boolean)m.invoke(null,null)).booleanValue();
      return bool;
    }
 catch (    Exception e) {
      Log.d(TAG,"could not determine if autosync is enabled, assuming yes");
      return true;
    }
  }
 else {
    return true;
  }
}
 

public Cursor getSuggestions(String query,int limit){
  Uri.Builder uriBuilder=new Uri.Builder().scheme(ContentResolver.SCHEME_CONTENT).query("").fragment("");
  uriBuilder.appendPath(SearchManager.SUGGEST_URI_PATH_QUERY);
  uriBuilder.appendPath(query);
  if (limit > 0) {
    uriBuilder.appendQueryParameter(SearchManager.SUGGEST_PARAMETER_LIMIT,String.valueOf(limit));
  }
  Uri uri=uriBuilder.build();
  return mContext.getContentResolver().query(uri,null,null,null,null);
}
 

private static void initCompatibility(){
  try {
    methodContentResolver_addPeriodicSync=ContentResolver.class.getMethod("addPeriodicSync",new Class[]{Account.class,String.class,Bundle.class,Long.TYPE});
  }
 catch (  NoSuchMethodException nsme) {
    Log.w(TAG,"Periodic sync not available - addPeriodicSync() method not found.",nsme);
  }
}
 

private void finishLogin(){
  Account account=new Account(mUsername,Constants.ACCOUNT_TYPE_ADMOB);
  if (mRequestNewAccount) {
    mAccountManager.addAccountExplicitly(account,mPassword,null);
    ContentResolver.setSyncAutomatically(account,ContactsContract.AUTHORITY,true);
  }
 else {
    mAccountManager.setPassword(account,mPassword);
  }
  Intent intent=new Intent();
  mAuthtoken=mPassword;
  intent.putExtra(AccountManager.KEY_ACCOUNT_NAME,mUsername);
  intent.putExtra(AccountManager.KEY_ACCOUNT_TYPE,Constants.ACCOUNT_TYPE_ADMOB);
  if (mAuthtokenType != null && mAuthtokenType.equals(Constants.AUTHTOKEN_TYPE_ADMOB)) {
    intent.putExtra(AccountManager.KEY_AUTHTOKEN,mAuthtoken);
  }
  setAccountAuthenticatorResult(intent.getExtras());
  setResult(RESULT_OK,intent);
  finish();
}
 

@Override public ArrayList<ContentProviderOperation> parse(XmlPullParser parser,ContentResolver resolver) throws XmlPullParserException, IOException {
  final ArrayList<ContentProviderOperation> batch=new ArrayList<ContentProviderOperation>();
  parser.require(XmlPullParser.START_TAG,null,"feed");
  while (parser.next() != XmlPullParser.END_DOCUMENT) {
    if (parser.getEventType() != XmlPullParser.START_TAG) {
      continue;
    }
    final String name=parser.getName();
    if ("entry".equals(name)) {
      final SpreadsheetEntry entry=SpreadsheetEntry.fromParser(parser);
      final Uri scheduleUri=Uri.withAppendedPath(mUri,Uri.encode(entry.get("title")));
      final long localUpdated=queryItemUpdated(scheduleUri,resolver);
      final long serverUpdated=entry.getUpdated();
      LOGV(TAG,"found schedule localUpdated=" + localUpdated + ", server="+ serverUpdated);
      if (localUpdated >= serverUpdated) {
        continue;
      }
      batch.add(ContentProviderOperation.newDelete(scheduleUri).build());
      final ContentProviderOperation.Builder builder=ContentProviderOperation.newInsert(mUri);
      builder.withValue("updated",serverUpdated);
      builder.withValue("date",entry.get("title"));
      builder.withValue("time",entry.get("time"));
      builder.withValue("school",entry.get("school"));
      batch.add(builder.build());
    }
  }
  return batch;
}
 

/** 
 * Create a new channel sync thread and start it.
 * @param client The asmack client.
 * @param via The jid used for sending requests.
 * @param resolver The content resolver used for the roster lookup.
 */
public ChannelSync(AsmackClient client,String via,ContentResolver resolver){
  super(client,via);
  this.resolver=resolver;
  roster=new HashMap<String,Long>();
  start();
}
 

public synchronized void cancelThreadDecoding(Thread t,ContentResolver cr){
  ThreadStatus status=getOrCreateThreadStatus(t);
  status.mState=State.CANCEL;
  if (status.mOptions != null) {
    status.mOptions.requestCancelDecode();
  }
  notifyAll();
  try {
synchronized (status) {
      while (status.mThumbRequesting) {
        Images.Thumbnails.cancelThumbnailRequest(cr,t.getId());
        Video.Thumbnails.cancelThumbnailRequest(cr,t.getId());
        status.wait(200);
      }
    }
  }
 catch (  InterruptedException ex) {
  }
}
 

/** 
 * Specifies a content URI to watch for changes.
 * @param cr The content resolver from the caller's context.
 * @param notifyUri The URI to watch for changes. This can be aspecific row URI, or a base URI for a whole class of content.
 */
public void setNotificationUri(ContentResolver cr,Uri notifyUri){
synchronized (mSelfObserverLock) {
    mNotifyUri=notifyUri;
    mContentResolver=cr;
    if (mSelfObserver != null) {
      mContentResolver.unregisterContentObserver(mSelfObserver);
    }
    mSelfObserver=new SelfContentObserver(this);
    mContentResolver.registerContentObserver(mNotifyUri,true,mSelfObserver);
    mSelfObserverRegistered=true;
  }
}
 

/** 
 * Get Attribution ID for app install conversion tracking.
 * @param contentResolver
 * @return Attribution ID that will be used for conversion tracking. It will be null only ifthe user has not installed or logged in to the Facebook app.
 */
public static String getAttributionId(ContentResolver contentResolver){
  String[] projection={ATTRIBUTION_ID_COLUMN_NAME};
  Cursor c=contentResolver.query(ATTRIBUTION_ID_CONTENT_URI,projection,null,null,null);
  if (c == null || !c.moveToFirst()) {
    return null;
  }
  String attributionId=c.getString(c.getColumnIndex(ATTRIBUTION_ID_COLUMN_NAME));
  return attributionId;
}
 

public void playDtmf(ContentResolver r,char dtmf){
  try {
    if (Settings.System.getInt(r,Settings.System.DTMF_TONE_WHEN_DIALING) == 0) {
      return;
    }
  }
 catch (  SettingNotFoundException e) {
  }
  getLc().playDtmf(dtmf,-1);
}
 

@Override protected ContentValues[] parse(JsonNode result,ContentResolver resolver){
  final long now=System.currentTimeMillis();
  Log.d(TAG,"Building queries for album's drop and create.");
  final ArrayNode albums=(ArrayNode)result.get(AbstractCall.RESULT).get(AudioLibrary.GetAlbums.RESULTS);
  final ContentValues[] batch=new ContentValues[albums.size()];
  for (int i=0; i < albums.size(); i++) {
    final ObjectNode album=(ObjectNode)albums.get(i);
    batch[i]=new ContentValues();
    batch[i].put(SyncColumns.UPDATED,now);
    batch[i].put(Albums.ID,album.get(AudioModel.AlbumDetails.ALBUMID).getIntValue());
    batch[i].put(Albums.TITLE,album.get(AudioModel.AlbumDetails.TITLE).getTextValue());
    batch[i].put(Albums.PREFIX + Artists.ID,album.get(AudioModel.AlbumDetails.ARTISTID).getIntValue());
    batch[i].put(Albums.YEAR,album.get(AudioModel.AlbumDetails.YEAR).getIntValue());
  }
  Log.d(TAG,batch.length + " album queries built in " + (System.currentTimeMillis() - now)+ "ms.");
  return batch;
}
 

public Cursor getSuggestions(SearchableInfo searchable,String query,int limit){
  if (searchable == null) {
    return null;
  }
  String authority=searchable.getSuggestAuthority();
  if (authority == null) {
    return null;
  }
  Uri.Builder uriBuilder=new Uri.Builder().scheme(ContentResolver.SCHEME_CONTENT).authority(authority).query("").fragment("");
  final String contentPath=searchable.getSuggestPath();
  if (contentPath != null) {
    uriBuilder.appendEncodedPath(contentPath);
  }
  uriBuilder.appendPath(SearchManager.SUGGEST_URI_PATH_QUERY);
  String selection=searchable.getSuggestSelection();
  String[] selArgs=null;
  if (selection != null) {
    selArgs=new String[]{query};
  }
 else {
    uriBuilder.appendPath(query);
  }
  if (limit > 0) {
    uriBuilder.appendQueryParameter(SearchManager.SUGGEST_PARAMETER_LIMIT,String.valueOf(limit));
  }
  Uri uri=uriBuilder.build();
  return getContentResolver().query(uri,null,selection,selArgs,null);
}
 

@Override public ArrayList<ContentProviderOperation> parse(XmlPullParser parser,ContentResolver resolver) throws XmlPullParserException, IOException {
  final ArrayList<ContentProviderOperation> batch=Lists.newArrayList();
  final String selection=Blocks.BLOCK_TYPE + "=? OR " + Blocks.BLOCK_TYPE+ "=?";
  final String[] selectionArgs={ParserUtils.BLOCK_TYPE_FOOD,ParserUtils.BLOCK_TYPE_OFFICE_HOURS};
  batch.add(ContentProviderOperation.newDelete(Blocks.CONTENT_URI).withSelection(selection,selectionArgs).build());
  int type;
  while ((type=parser.next()) != END_DOCUMENT) {
    if (type == START_TAG && Tags.BLOCK.equals(parser.getName())) {
      batch.add(parseBlock(parser));
    }
  }
  return batch;
}