Project: platform_packages_apps_browser
/*
 * Copyright (C) 2011 The Android Open Source Project 
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); 
 * you may not use this file except in compliance with the License. 
 * You may obtain a copy of the License at 
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0 
 * 
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS, 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 * See the License for the specific language governing permissions and 
 * limitations under the License. 
 */
 
package com.android.browser.tests.utils; 
 
import com.google.android.collect.Maps; 
 
import android.content.ContentProvider; 
import android.content.ContentResolver; 
import android.content.Context; 
import android.content.IContentProvider; 
import android.database.ContentObserver; 
import android.net.Uri; 
 
import java.util.Map; 
 
public class MockContentResolver2 extends ContentResolver { 
 
    Map<String, ContentProvider> mProviders; 
    private final MockObserverNode mRootNode = new MockObserverNode(""); 
 
    /*
     * Creates a local map of providers. This map is used instead of the global map when an 
     * API call tries to acquire a provider. 
     */
 
    public MockContentResolver2() { 
        super(null); 
        mProviders = Maps.newHashMap(); 
    } 
 
    /**
     * Adds access to a provider based on its authority 
     * 
     * @param name The authority name associated with the provider. 
     * @param provider An instance of {@link android.content.ContentProvider} or one of its 
     * subclasses, or null. 
     */
 
    public void addProvider(String name, ContentProvider provider) { 
 
        /*
         * Maps the authority to the provider locally. 
         */
 
        mProviders.put(name, provider); 
    } 
 
    /** @hide */ 
    @Override 
    protected IContentProvider acquireProvider(Context context, String name) { 
        return acquireExistingProvider(context, name); 
    } 
 
    /** @hide */ 
    @Override 
    protected IContentProvider acquireExistingProvider(Context context, String name) { 
 
        /*
         * Gets the content provider from the local map 
         */
 
        final ContentProvider provider = mProviders.get(name); 
 
        if (provider != null) { 
            return provider.getIContentProvider(); 
        } else { 
            return null
        } 
    } 
 
    /** @hide */ 
    @Override 
    public boolean releaseProvider(IContentProvider provider) { 
        return true
    } 
 
    /** @hide */ 
    protected IContentProvider acquireUnstableProvider(Context c, String name) { 
        return acquireProvider(c, name); 
    } 
 
    /** @hide */ 
    public boolean releaseUnstableProvider(IContentProvider icp) { 
        return releaseProvider(icp); 
    } 
 
    /** @hide */ 
    public void unstableProviderDied(IContentProvider icp) { 
    } 
 
    @Override 
    public void notifyChange(Uri uri, ContentObserver observer, 
            boolean syncToNetwork) { 
        mRootNode.notifyMyObservers(uri, 0, observer, false); 
    } 
 
    public void safeRegisterContentObserver(Uri uri, boolean notifyForDescendents, 
            ContentObserver observer) { 
        mRootNode.addObserver(uri, observer, notifyForDescendents); 
    } 
 
    public void safeUnregisterContentObserver(ContentObserver observer) { 
        mRootNode.removeObserver(observer); 
    } 
 
}