Uri uri = Uri.parse(uriString);
String mime=getContentResolver().getType(uri);

public final @Nullable String getType(@NonNull Uri url) {
    Objects.requireNonNull(url, "url");
    //...
    IContentProvider provider = acquireExistingProvider(url);
    if (provider != null) {
        try {
            final StringResultListener resultListener = new StringResultListener();
            provider.getTypeAsync(url, new RemoteCallback(resultListener));
            resultListener.waitForResult(CONTENT_PROVIDER_TIMEOUT_MILLIS);
            if (resultListener.exception != null) {
                throw resultListener.exception;
            }
            return resultListener.result;
        } catch (RemoteException e) {
            // ...
        }
    }


    try {
        final StringResultListener resultListener = new StringResultListener();
        ActivityManager.getService().getProviderMimeTypeAsync(
                ContentProvider.getUriWithoutUserId(url),
                resolveUserId(url),
                new RemoteCallback(resultListener));
        resultListener.waitForResult(REMOTE_CONTENT_PROVIDER_TIMEOUT_MILLIS);
        if (resultListener.exception != null) {
            throw resultListener.exception;
        }
        return resultListener.result;
    } catch (RemoteException e) {
        // ...
        return null;
    }
 }

/**
 * Allows apps to retrieve the MIME type of a URI.
 * If an app is in the same user as the ContentProvider, or if it is allowed to interact across
 * users, then it does not need permission to access the ContentProvider.
 * Either way, it needs cross-user uri grants.
 */
@Override
public void getProviderMimeTypeAsync(Uri uri, int userId, RemoteCallback resultCallback) {
    mCpHelper.getProviderMimeTypeAsync(uri, userId, resultCallback);
}

void getProviderMimeTypeAsync(Uri uri, int userId, RemoteCallback resultCallback) {
    mService.enforceNotIsolatedCaller("getProviderMimeTypeAsync");
    final String name = uri.getAuthority();
    final int callingUid = Binder.getCallingUid();
    final int callingPid = Binder.getCallingPid();
    final int safeUserId = mService.mUserController.unsafeConvertIncomingUser(userId);
    final long ident = canClearIdentity(callingPid, callingUid, userId)
            ? Binder.clearCallingIdentity() : 0;
    try {
        final ContentProviderHolder holder = getContentProviderExternalUnchecked(name, null,
                callingUid, "*getmimetype*", safeUserId);
        if (holder != null) {
            holder.provider.getTypeAsync(uri, new RemoteCallback(result -> {
                final long identity = Binder.clearCallingIdentity();
                try {
                    removeContentProviderExternalUnchecked(name, null, safeUserId);
                } finally {
                    Binder.restoreCallingIdentity(identity);
                }
                resultCallback.sendResult(result);
            }));
        } else {
            resultCallback.sendResult(Bundle.EMPTY);
        }
    } catch (RemoteException e) {
        Log.w(TAG, "Content provider dead retrieving " + uri, e);
        resultCallback.sendResult(Bundle.EMPTY);
    } finally {
        Binder.restoreCallingIdentity(ident);
    }
}

ContentProviderHolder getContentProviderExternalUnchecked(String name,
        IBinder token, int callingUid, String callingTag, int userId) {
    return getContentProviderImpl(null, name, token, callingUid, null, callingTag,
            true, userId);
}

synchronized (cpr) {
    while (cpr.provider == null) {
        if (cpr.launchingApp == null) {
            //...
            return null;
        }
        try {
            final long wait = Math.max(0L, timeout - SystemClock.uptimeMillis());
            if (DEBUG_MU) {
                Slog.v(TAG_MU, "Waiting to start provider " + cpr
                       + " launchingApp=" + cpr.launchingApp + " for " + wait + " ms");
            }
            if (conn != null) {
                conn.waiting = true;
            }
            cpr.wait(wait);
            if (cpr.provider == null) {
                timedOut = true;
                break;
            }
        } catch (InterruptedException ex) {
        } finally {
            if (conn != null) {
                conn.waiting = false;
            }
        }
    }
}

try {
    final StringResultListener resultListener = new StringResultListener();
    provider.getTypeAsync(url, new RemoteCallback(resultListener));
    resultListener.waitForResult(CONTENT_PROVIDER_TIMEOUT_MILLIS);
    if (resultListener.exception != null) {
        throw resultListener.exception;
    }
    return resultListener.result;
}

holder.provider.getTypeAsync(uri, new RemoteCallback(result -> {
    final long identity = Binder.clearCallingIdentity();
    try {
        removeContentProviderExternalUnchecked(name, null, safeUserId);
    } finally {
        Binder.restoreCallingIdentity(identity);
    }
    resultCallback.sendResult(result);
}));

@Override
public void getTypeAsync(Uri uri, RemoteCallback callback) {
    final Bundle result = new Bundle();
    try {
        result.putString(ContentResolver.REMOTE_CALLBACK_RESULT, getType(uri));
    } catch (Exception e) {
        result.putParcelable(ContentResolver.REMOTE_CALLBACK_ERROR,
                new ParcelableException(e));
    }
    callback.sendResult(result);
}

public void sendResult(@Nullable final Bundle result) {
    // Do local dispatch
    if (mListener != null) {
        if (mHandler != null) {
            mHandler.post(new Runnable() {
                @Override
                public void run() {
                    mListener.onResult(result);
                }
            });
        } else {
            mListener.onResult(result);
        }
    // Do remote dispatch
    } else {
        try {
            mCallback.sendResult(result);
        } catch (RemoteException e) {
            /* ignore */
        }
    }
}

@Override
public void onResult(Bundle result) {
    synchronized (this) {
        ParcelableException e = result.getParcelable(REMOTE_CALLBACK_ERROR);
        if (e != null) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                this.exception = (RuntimeException) t;
            } else {
                this.exception = new RuntimeException(t);
            }
        } else {
            this.result = getResultFromBundle(result);
        }
        done = true;
        notifyAll();
    }
}

ContentProviderHolder getContentProviderExternalUnchecked(String name,
        IBinder token, int callingUid, String callingTag, int userId) {
    return getContentProviderImpl(null, name, token, callingUid, null, callingTag,
            true, userId);
}

int openContentProviderFile(const String16& uri){
    int fd = -1;

    sp<IServiceManager> sm = defaultServiceManager();
    sp<IBinder> binder = sm->getService(String16("activity"));
    sp<IActivityManager> am = interface_cast<IActivityManager>(binder);
    if (am != NULL) {
        fd = am->openContentUri(uri);
    }

    return fd;
}

ContentProviderHolder getContentProvider(IApplicationThread caller, String callingPackage,
        String name, int userId, boolean stable) {
    //...
    return getContentProviderImpl(caller, name, null, callingUid, callingPackage,
            null, stable, userId);
}

ContentProviderHolder getContentProviderExternalUnchecked(String name,
        IBinder token, int callingUid, String callingTag, int userId) {
    return getContentProviderImpl(null, name, token, callingUid, null, callingTag,
            true, userId);
}

proc = mService.startProcessLocked(
        cpi.processName, cpr.appInfo, false, 0,
        new HostingRecord(HostingRecord.HOSTING_TYPE_CONTENT_PROVIDER,
            new ComponentName(
                    cpi.applicationInfo.packageName, cpi.name)),
        // MIUI MOD:
        // Process.ZYGOTE_POLICY_FLAG_EMPTY, false, false);
        Process.ZYGOTE_POLICY_FLAG_EMPTY, false, false, callerPackage);

if (caller != null) {
    // The client will be waiting, and we'll notify it when the provider is ready.
    synchronized (cpr) {
        if (cpr.provider == null) {
            if (cpr.launchingApp == null) {
                //...
                return null;
            }

            if (conn != null) {
                conn.waiting = true;
            }
            Message msg = mService.mHandler.obtainMessage(
                    ActivityManagerService.WAIT_FOR_CONTENT_PROVIDER_TIMEOUT_MSG);
            msg.obj = cpr;
            mService.mHandler.sendMessageDelayed(msg,
                    ContentResolver.CONTENT_PROVIDER_READY_TIMEOUT_MILLIS);
        }
    }
    //...
    return cpr.newHolder(conn, false);
}

// Because of the provider's external client (i.e., SHELL), we'll have to wait right here.
// Wait for the provider to be published...
final long timeout =
        SystemClock.uptimeMillis() + ContentResolver.CONTENT_PROVIDER_READY_TIMEOUT_MILLIS;
boolean timedOut = false;
synchronized (cpr) {
    while (cpr.provider == null) {
        if (cpr.launchingApp == null) {
            //...
            return null;
        }
        try {
            final long wait = Math.max(0L, timeout - SystemClock.uptimeMillis());
            if (conn != null) {
                conn.waiting = true;
            }
            cpr.wait(wait);
            if (cpr.provider == null) {
                timedOut = true;
                break;
            }
        } catch (InterruptedException ex) {
        } finally {
            if (conn != null) {
                conn.waiting = false;
            }
        }
    }
}