Petal Maps v4.7.0.310001 - AwarenessClient.java 源代码

package com.huawei.hiai.awareness.dataaccess;

import android.content.ContentProviderClient;
import android.content.ContentResolver;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.content.pm.ProviderInfo;
import android.net.Uri;
import android.os.Bundle;
import android.text.TextUtils;
import com.huawei.android.app.ActivityManagerEx;
import com.huawei.android.content.ContentProviderEx;
import com.huawei.hiai.awareness.dataaccess.AwarenessClient;
import com.huawei.hiai.awareness.dataaccess.DataBean;
import com.huawei.hiai.awareness.dataaccess.message.Content;
import com.huawei.hiai.awareness.dataaccess.message.ContentData;
import com.huawei.hiai.awareness.dataaccess.message.InsightIntent;
import com.huawei.hiai.awareness.dataaccess.message.Message;
import com.huawei.hiai.awareness.dataaccess.message.Session;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.json.JSONException;
import org.json.JSONObject;

public class AwarenessClient {
    private static final String ARG_DELETE_SEND_CELIA_DATA_METHOD = "delete";
    private static final String ARG_UPDATE_SEND_CELIA_DATA_METHOD = "update";
    private static final String AWARENESS_PKG_NAME = "com.huawei.hiai";
    private static final String CELIA_BUNDLE_KEY_DATA_BEAN_LIST = "dataBeanList";
    private static final Uri CONTENT_URI = Uri.parse("content://com.huawei.hiai.awareness.externalData");
    private static final String DATA_ACCESS_METHOD = "reportData";
    private static final String DATA_BEAN_KEY_CONTENT = "content";
    private static final String DATA_BEAN_KEY_HEADER = "header";
    private static final String DATA_CONTENT = "Content";
    private static final String DATA_SOURCE = "source";
    private static final String DELETE_ENTITY_MESSAGE_NAME = "deleteEntity";
    private static final String DELETE_INTENT_MESSAGE_NAME = "deleteIntent";
    private static final String KEY_CONTENT = "content";
    private static final String KEY_SESSION = "session";
    private static final int MAX_SIZ = 100;
    private static final String MESSAGE_ACCESS_METHOD = "sendMessage";
    private static final String MESSAGE_ACCESS_METHOD_V2 = "sendMessageV2";
    private static final String SEND_CELIA_DATA_METHOD = "sendCeliaData";
    private static final String SEND_MESSAGE_MESSAGE_VERSION = "1.1";
    private static final String SHARE_INTENT_MESSAGE_NAME = "shareIntent";
    private static final String SHARE_INTENT_MESSAGE_VERSION = "3.1";
    private static final String TAG = "AwarenessClient";
    private final Context context;
    private Uri uri = CONTENT_URI;

    public AwarenessClient(Context context) {
        this.context = context;
    }

    private Bundle buildDataBundle(Message message) {
        Bundle bundle = new Bundle();
        bundle.putString("session", message.getSession().toJsonString());
        bundle.putString("content", message.getContent().toJsonString());
        return bundle;
    }

    private Session buildSession(String str) {
        Session session = new Session();
        session.setMessageName(str);
        session.setMessageVersion(SHARE_INTENT_MESSAGE_VERSION);
        session.setSourceType("2");
        return session;
    }

    private Bundle callAccessProvider(String str, String str2, Bundle bundle) {
        LogUtil.info(TAG, "callAccessProvider: " + str);
        try {
            ContentResolver contentResolver = this.context.getContentResolver();
            String authority = this.uri.getAuthority();
            Objects.requireNonNull(authority);
            ContentProviderClient acquireUnstableContentProviderClient = contentResolver.acquireUnstableContentProviderClient(authority);
            try {
                if (acquireUnstableContentProviderClient == null) {
                    LogUtil.error(TAG, "contentProviderClient is null");
                    Bundle connectServerError = Result.connectServerError();
                    if (acquireUnstableContentProviderClient != null) {
                        acquireUnstableContentProviderClient.close();
                    }
                    return connectServerError;
                }
                Bundle call = acquireUnstableContentProviderClient.call(str, str2, bundle);
                if (call != null) {
                    acquireUnstableContentProviderClient.close();
                    return call;
                }
                if (MESSAGE_ACCESS_METHOD_V2.equals(str)) {
                    LogUtil.info(TAG, "server return null, means not support sendMessageV2");
                    Bundle notSupport = Result.notSupport();
                    acquireUnstableContentProviderClient.close();
                    return notSupport;
                }
                LogUtil.error(TAG, "result is null");
                Bundle serverReturnNull = Result.serverReturnNull();
                acquireUnstableContentProviderClient.close();
                return serverReturnNull;
            } finally {
            }
        } catch (Exception unused) {
            LogUtil.error(TAG, "call provider exception");
            return Result.connectServerError();
        }
    }

    private Bundle checkIntents(List<InsightIntent> list) {
        if (list == null || list.isEmpty()) {
            LogUtil.error(TAG, "intents is empty");
            return Result.paramError();
        }
        Iterator<InsightIntent> it = list.iterator();
        while (it.hasNext()) {
            if (!isValid(it.next())) {
                LogUtil.error(TAG, "intent invalid");
                return Result.paramError();
            }
        }
        return Result.success();
    }

    private Bundle checkMessage(Message message, boolean z) {
        if (message == null || message.getSession() == null || message.getContent() == null) {
            LogUtil.error(TAG, "Invalid message");
            return Result.paramError();
        }
        Session session = message.getSession();
        String packageName = session.getPackageName();
        if (packageName == null || packageName.isEmpty()) {
            session.setPackageName(this.context.getPackageName());
        }
        Content content = message.getContent();
        if (z && content.getContentKeySize() > 100) {
            LogUtil.error(TAG, "Content is too big");
            return Result.paramSizeError();
        }
        String jsonString = session.toJsonString();
        String jsonString2 = content.toJsonString();
        if (jsonString != null && !jsonString.isEmpty() && jsonString2 != null && !jsonString2.isEmpty()) {
            return Result.success();
        }
        LogUtil.error(TAG, "session or content invalid");
        return Result.paramError();
    }

    private Content convertContent(List<InsightIntent> list) {
        ArrayList arrayList = new ArrayList();
        Iterator<InsightIntent> it = list.iterator();
        while (it.hasNext()) {
            arrayList.add(toContentData(it.next()));
        }
        Content content = new Content();
        content.setContentDatas(arrayList);
        return content;
    }

    private ArrayList<String> convertDataBeanList(List<DataBean> list) {
        return (ArrayList) list.stream().map(new Function() {
            @Override
            public final Object apply(Object obj) {
                String lambda$convertDataBeanList$1;
                lambda$convertDataBeanList$1 = AwarenessClient.lambda$convertDataBeanList$1((DataBean) obj);
                return lambda$convertDataBeanList$1;
            }
        }).collect(Collectors.toCollection(new Supplier() {
            @Override
            public final Object get() {
                return new ArrayList();
            }
        }));
    }

    private Content convertDeleteEntityContent(String str, String[] strArr) {
        return convertContent(str, Constant.PAYLOAD_KEY_ENTITY_IDS, strArr);
    }

    private Message convertDeleteEntityMessage(String str, String[] strArr) {
        return convertMessage(DELETE_ENTITY_MESSAGE_NAME, convertDeleteEntityContent(str, strArr));
    }

    private Content convertDeleteIntentContent(String str, String[] strArr) {
        return convertContent(str, Constant.PAYLOAD_KEY_IDENTIFIERS, strArr);
    }

    private Message convertDeleteIntentMessage(String str, String[] strArr) {
        return convertMessage(DELETE_INTENT_MESSAGE_NAME, convertDeleteIntentContent(str, strArr));
    }

    private Message convertMessage(String str, Content content) {
        Message message = new Message();
        message.setSession(buildSession(str));
        message.setContent(content);
        return message;
    }

    private Message convertShareIntentMessage(List<InsightIntent> list) {
        return convertMessage(SHARE_INTENT_MESSAGE_NAME, convertContent(list));
    }

    private boolean isAwarenessProvider() {
        ApplicationInfo applicationInfo;
        PackageManager packageManager = this.context.getPackageManager();
        boolean z = false;
        if (packageManager == null) {
            LogUtil.error(TAG, "pkgManager == null");
            return false;
        }
        ProviderInfo resolveContentProvider = packageManager.resolveContentProvider(CONTENT_URI.getAuthority(), 0);
        if (resolveContentProvider != null && (applicationInfo = resolveContentProvider.applicationInfo) != null) {
            String str = applicationInfo.packageName;
            LogUtil.info(TAG, "pkgName " + str);
            if (packageManager.checkSignatures("com.huawei.hiai", str) == 0) {
                z = true;
            }
        }
        LogUtil.info(TAG, "isAwarenessProvider " + z);
        return z;
    }

    private static boolean isValid(InsightIntent insightIntent) {
        return insightIntent != null && Stream.of(insightIntent.getIdentifier(), insightIntent.getIntentName(), insightIntent.getIntentVersion(), insightIntent.getIntentActionInfo(), insightIntent.getIntentEntityInfo()).noneMatch(new Predicate() {
            @Override
            public final boolean test(Object obj) {
                return Objects.isNull(obj);
            }
        });
    }

    public static String lambda$convertDataBeanList$1(DataBean dataBean) {
        JSONObject jSONObject = new JSONObject();
        try {
            jSONObject.put(DATA_BEAN_KEY_HEADER, dataBean.getHeaderJsonFromBundle());
            jSONObject.put("content", dataBean.getContent());
        } catch (JSONException unused) {
            LogUtil.error(TAG, "convertDataBeanList, JSONException occurs.");
        }
        return jSONObject.toString();
    }

    private static ContentData toContentData(InsightIntent insightIntent) {
        ContentData header = new ContentData().setHeader(Constant.HEADER_KEY_NAMESPACE, "intent");
        if (insightIntent != null) {
            header.setHeader("name", insightIntent.getIntentName()).setPayload(Constant.PAYLOAD_KEY_IDENTIFIER, insightIntent.getIdentifier()).setPayload(Constant.PAYLOAD_KEY_INTENT_VERSION, insightIntent.getIntentVersion()).setPayload(Constant.PAYLOAD_KEY_INTENT_ACTION_INFO, insightIntent.getIntentActionInfo()).setPayload(Constant.PAYLOAD_KEY_INTENT_ENTITY_INFO, insightIntent.getIntentEntityInfo()).setPayload(Constant.PAYLOAD_KEY_CUSTOM_FORM_INFO, insightIntent.getCustomFormInfo()).setPayload(Constant.PAYLOAD_KEY_INTENT_TARGET_INFO, insightIntent.getIntentTargetInfo());
        }
        return header;
    }

    public Optional<Bundle> deleteCeliaData(List<DataBean> list) {
        LogUtil.info(TAG, "deleteCeliaData starts.");
        new Bundle();
        if (!isAwarenessProvider()) {
            LogUtil.error(TAG, "deleteCeliaData, isAwarenessProvider check failed.");
            return Optional.of(Result.connectServerError());
        }
        if (list == null) {
            LogUtil.error(TAG, "deleteCeliaData, dataBeanList is null.");
            return Optional.of(Result.paramError());
        }
        if (list.size() > 100) {
            LogUtil.error(TAG, "deleteCeliaData, the size of dataBeanList exceeds the limit.");
            return Optional.of(Result.paramSizeError());
        }
        Bundle bundle = new Bundle();
        bundle.putStringArrayList(CELIA_BUNDLE_KEY_DATA_BEAN_LIST, convertDataBeanList(list));
        return Optional.ofNullable(callAccessProvider(SEND_CELIA_DATA_METHOD, ARG_DELETE_SEND_CELIA_DATA_METHOD, bundle));
    }

    public Bundle deleteEntity(String str, String[] strArr) {
        LogUtil.info(TAG, "deleteEntity: " + str);
        if (str != null) {
            return sendMessage(MESSAGE_ACCESS_METHOD_V2, convertDeleteEntityMessage(str, strArr));
        }
        LogUtil.error(TAG, "entityName is null");
        return Result.paramError();
    }

    public Bundle deleteIntent(String str, String[] strArr) {
        LogUtil.info(TAG, "deleteIntent: " + str);
        if (str != null) {
            return sendMessage(MESSAGE_ACCESS_METHOD_V2, convertDeleteIntentMessage(str, strArr));
        }
        LogUtil.error(TAG, "intentName is null");
        return Result.paramError();
    }

    public boolean reportData(DataBean dataBean) {
        if (dataBean == null || this.context == null) {
            LogUtil.error(TAG, "dataBean is null");
            return false;
        }
        if (!isAwarenessProvider()) {
            return false;
        }
        if (TextUtils.isEmpty(dataBean.getStringContent("source"))) {
            dataBean.setContent("source", this.context.getPackageName());
        }
        if (dataBean.getContentSize() > 100 || dataBean.getHeaderSize() > 100) {
            LogUtil.error(TAG, "Bundle is too big");
            return false;
        }
        dataBean.getBundle().putString(DATA_CONTENT, dataBean.getContent());
        return Result.isSuccess(callAccessProvider(DATA_ACCESS_METHOD, null, dataBean.getBundle()));
    }

    public boolean reportDataCrossUser(DataBean dataBean) {
        try {
            int currentUser = ActivityManagerEx.getCurrentUser();
            this.uri = ContentProviderEx.maybeAddUserId(CONTENT_URI, currentUser);
            LogUtil.info(TAG, "uerId is " + currentUser + " and uri is " + this.uri);
            return reportData(dataBean);
        } catch (Throwable th) {
            LogUtil.error(TAG, "reportDataCrossUser exception: " + th.getMessage());
            return false;
        }
    }

    public boolean sendMessage(Message message) {
        LogUtil.info(TAG, MESSAGE_ACCESS_METHOD);
        Optional.ofNullable(message).map(new Function() {
            @Override
            public final Object apply(Object obj) {
                return ((Message) obj).getSession();
            }
        }).ifPresent(new Consumer() {
            @Override
            public final void accept(Object obj) {
                ((Session) obj).setMessageVersion(AwarenessClient.SEND_MESSAGE_MESSAGE_VERSION);
            }
        });
        return Result.isSuccess(sendMessage(MESSAGE_ACCESS_METHOD, message, true));
    }

    public Bundle shareIntent(List<InsightIntent> list) {
        StringBuilder sb = new StringBuilder();
        sb.append("shareIntent: ");
        sb.append(list == null ? "null" : String.valueOf(list.size()));
        LogUtil.info(TAG, sb.toString());
        Bundle checkIntents = checkIntents(list);
        if (Result.isSuccess(checkIntents)) {
            return sendMessage(MESSAGE_ACCESS_METHOD_V2, convertShareIntentMessage(list));
        }
        LogUtil.error(TAG, "missing param");
        return checkIntents;
    }

    public Optional<Bundle> updateCeliaData(List<DataBean> list) {
        LogUtil.info(TAG, "updateCeliaData starts.");
        new Bundle();
        if (!isAwarenessProvider()) {
            LogUtil.error(TAG, "updateCeliaData, isAwarenessProvider check failed.");
            return Optional.of(Result.connectServerError());
        }
        if (list == null) {
            LogUtil.error(TAG, "updateCeliaData, dataBeanList is null.");
            return Optional.of(Result.paramError());
        }
        if (list.size() > 100) {
            LogUtil.error(TAG, "updateCeliaData, the size of dataBeanList exceeds the limit.");
            return Optional.of(Result.paramSizeError());
        }
        Bundle bundle = new Bundle();
        bundle.putStringArrayList(CELIA_BUNDLE_KEY_DATA_BEAN_LIST, convertDataBeanList(list));
        return Optional.of(callAccessProvider(SEND_CELIA_DATA_METHOD, ARG_UPDATE_SEND_CELIA_DATA_METHOD, bundle));
    }

    public Bundle deleteIntent(String str) {
        return deleteIntent(str, new String[0]);
    }

    private Content convertContent(String str, String str2, String[] strArr) {
        ArrayList arrayList = new ArrayList();
        arrayList.add(new ContentData().setHeader(Constant.HEADER_KEY_NAMESPACE, "intent").setHeader("name", str).setPayload(str2, strArr));
        Content content = new Content();
        content.setContentDatas(arrayList);
        return content;
    }

    private Bundle sendMessage(String str, Message message) {
        return sendMessage(str, message, false);
    }

    private Bundle sendMessage(String str, Message message, boolean z) {
        if (this.context == null) {
            LogUtil.error(TAG, "context is null");
            return Result.paramError();
        }
        if (!isAwarenessProvider()) {
            return Result.connectServerError();
        }
        Bundle checkMessage = checkMessage(message, z);
        return !Result.isSuccess(checkMessage) ? checkMessage : callAccessProvider(str, null, buildDataBundle(message));
    }
}