final ArrayMap<ProviderKey, ProviderClientRecord> mProviderMap
    = new ArrayMap<ProviderKey, ProviderClientRecord>();

final ArrayMap<IBinder, ProviderClientRecord> mLocalProviders
    = new ArrayMap<IBinder, ProviderClientRecord>();

final ArrayMap<ComponentName, ProviderClientRecord> mLocalProvidersByName
        = new ArrayMap<ComponentName, ProviderClientRecord>();

final ArrayMap<ProviderKey, ProviderKey> mGetProviderKeys = new ArrayMap<>();

private ProviderKey getGetProviderKey(String auth, int userId) {
    final ProviderKey key = new ProviderKey(auth, userId);
    synchronized (mGetProviderKeys) {
        ProviderKey lock = mGetProviderKeys.get(key);
        if (lock == null) {
            lock = key;
            mGetProviderKeys.put(key, lock);
        }
        return lock;
    }
}

public final ContentProviderRecord provider;
public final ProcessRecord client;
public final String clientPackage;
public AssociationState.SourceState association;
public final long createTime;
private Object mProcStatsLock;  // Internal lock for accessing AssociationState

/**
 * Internal lock that guards access to the two counters.
 */
private final Object mLock = new Object();
@GuardedBy("mLock")
private int mStableCount;
@GuardedBy("mLock")
private int mUnstableCount;
// The client of this connection is currently waiting for the provider to appear.
// Protected by the provider lock.
public boolean waiting;
// The provider of this connection is now dead.
public boolean dead;

// The original user id when this connection was requested, it could be different from
// the client's user id because the client could request to access a content provider
// living in a different user if it has the permission.
@UserIdInt final int mExpectedUserId;

// For debugging.
private int mNumStableIncs;
private int mNumUnstableIncs;

/**
 * Activity manager code dealing with content providers.
 */
public class ContentProviderHelper {
    private static final String TAG = "ContentProviderHelper";

    private final ActivityManagerService mService;

    /**
     * List of content providers who have clients waiting for them.  The
     * application is currently being launched and the provider will be
     * removed from this list once it is published.
     */
    private final ArrayList<ContentProviderRecord> mLaunchingProviders = new ArrayList<>();
    private final ProviderMap mProviderMap;
    private boolean mSystemProvidersInstalled;

    ContentProviderHelper(ActivityManagerService service, boolean createProviderMap) {
        mService = service;
        mProviderMap = createProviderMap ? new ProviderMap(mService) : null;
    }
    //......
}

public final ProviderInfo info;

public IContentProvider provider;
public IBinder connection;

public boolean noReleaseNeeded;

/**
 * Whether the provider here is a local provider or not.
 */
public boolean mLocal;

// Maximum attempts to bring up the content provider before giving up.
static final int MAX_RETRY_COUNT = 3;

final ActivityManagerService service;
public final ProviderInfo info;
final int uid;
final ApplicationInfo appInfo;
final ComponentName name;
final boolean singleton;
public IContentProvider provider;
public boolean noReleaseNeeded;
// All attached clients
final ArrayList<ContentProviderConnection> connections
        = new ArrayList<ContentProviderConnection>();
//final HashSet<ProcessRecord> clients = new HashSet<ProcessRecord>();
// Handles for non-framework processes supported by this provider
ArrayMap<IBinder, ExternalProcessHandle> externalProcessTokenToHandle;
// Count for external process for which we have no handles.
int externalProcessNoHandleCount;
int mRestartCount; // number of times we tried before bringing up it successfully.
ProcessRecord proc; // if non-null, hosting process.
ProcessRecord launchingApp; // if non-null, waiting for this app to be launched.
String stringName;
String shortStringName;

private static final class ProviderKey {
    final String authority;
    final int userId;

    @GuardedBy("mLock")
    ContentProviderHolder mHolder; // Temp holder to be used between notifier and waiter
    final Object mLock; // The lock to be used to get notified when the provider is ready

    public ProviderKey(String authority, int userId) {
        this.authority = authority;
        this.userId = userId;
        this.mLock = new Object();
    }

    @Override
    public boolean equals(@Nullable Object o) {
        if (o instanceof ProviderKey) {
            final ProviderKey other = (ProviderKey) o;
            return Objects.equals(authority, other.authority) && userId == other.userId;
        }
        return false;
    }

    @Override
    public int hashCode() {
        return ((authority != null) ? authority.hashCode() : 0) ^ userId;
    }
}

private ProviderKey getGetProviderKey(String auth, int userId) {
    final ProviderKey key = new ProviderKey(auth, userId);
    synchronized (mGetProviderKeys) {
        ProviderKey lock = mGetProviderKeys.get(key);
        if (lock == null) {
            lock = key;
            mGetProviderKeys.put(key, lock);
        }
        return lock;
    }
}