LoginInfo.java

浏览该文件的文档.

package com.netease.nimlib.sdk.auth;

import android.os.Parcel;
import android.os.Parcelable;
import android.text.TextUtils;

import androidx.annotation.NonNull;

import com.netease.nimlib.SDKCache;
import com.netease.nimlib.biz.constant.IAuthService;
import com.netease.nimlib.log.NimLog;
import com.netease.nimlib.util.StringUtil;

import org.json.JSONException;
import org.json.JSONObject;

import java.io.Serializable;
import java.util.Objects;

/**
 * 用户登录认证信息。
 */
public class LoginInfo implements Serializable, Parcelable {
    private static final String KEY_ACCOUNT = "KEY_ACCOUNT";
    private static final String KEY_TOKEN = "KEY_TOKEN";
    private static final String KEY_AUTH_TYPE = "KEY_AUTH_TYPE";
    private static final String KEY_LOGIN_EXT = "KEY_LOGIN_EXT";
    private static final String KEY_APP_KEY = "KEY_APP_KEY";
    private static final String KEY_CUSTOM_CLIENT_TYPE = "KEY_CUSTOM_CLIENT_TYPE";


    private final String account;

    private final String token;

    private int authType;

    private String loginExt;

    private String appKey;

    private int customClientType;

    /**
     * 构造用户登录信息。
     * @par 参数说明：
     * <table>
     * <tr>
     * <th>**参数名称**</th>
     * <th>**描述**</th>
     * </tr>
     * <tr>
     * <td>account</td>
     * <td>用户账号，对应云信 IM 账号 accid</td>
     * </tr>
     * <tr>
     * <td>token</td>
     * <td>登录 token</td>
     * </tr>
     * </table>
     */
    public LoginInfo(String account, String token) {
        this.account = account == null ? null : account.toLowerCase();
        this.token = token;
    }

    /**
     * 构造用户登录信息。
     * @par 参数说明：
     * <table>
     * <tr>
     * <th>**参数名称**</th>
     * <th>**描述**</th>
     * </tr>
     * <tr>
     * <td>account</td>
     * <td>用户账号，对应云信 IM 账号 accid</td>
     * </tr>
     * <tr>
     * <td>token</td>
     * <td>登录 token</td>
     * </tr>
     * <tr>
     * <td>appKey</td>
     * <td>当前应用的 AppKey<br>一个 AppKey 对应一个账号体系，如果不填，则优先使用 SDKOptions 中配置的 AppKey，如果没有则使用 AndroidManifest 中配置的 AppKey<br>即 AppKey 的取值优先级为：LoginInfo中的>SDKOptions 中的>AndroidManifest 中的 AppKey</td>
     * </tr>
     * </table>
     */
    public LoginInfo(String account, String token, String appKey) {
        this(account, token);
        this.appKey = appKey;
    }



    /**
     * 构造用户登录信息。
     * @par 参数说明：
     * <table>
     * <tr>
     * <th>**参数名称**</th>
     * <th>**描述**</th>
     * </tr>
     * <tr>
     * <td>account</td>
     * <td>用户账号，对应云信 IM 账号 accid</td>
     * </tr>
     * <tr>
     * <td>token</td>
     * <td>登录 token</td>
     * </tr>
     * <tr>
     * <td>appKey</td>
     * <td>当前应用的 AppKey<br>一个 AppKey 对应一个账号体系，如果不填，则优先使用 SDKOptions 中配置的 AppKey，如果没有则使用 AndroidManifest 中配置的 AppKey<br>即 AppKey 的取值优先级为：LoginInfo中的>SDKOptions 中的>AndroidManifest 中的 AppKey</td>
     * </tr>
     * <tr>
     * <td>customClientType</td>
     * <td>自定义客户端类型，对应云信控制台中的自定义终端类型（需提前在控制台添加）。小于等于 0 视为没有自定义类型</td>
     * </tr>
     * </table>
     */
    public LoginInfo(String account, String token, String appKey, int customClientType) {
        this(account, token, appKey);
        this.customClientType = customClientType;
    }

    /**
     * 构造用户登录信息。
     * @par 使用场景：
     * 当需要在登录时传入 authType 或 loginExt 时，即需要通过动态登录或第三方回调登录时，需要使用该构造函数。
     * */
    protected LoginInfo(Parcel in) {
        account = in.readString();
        token = in.readString();

        authType = in.readInt();
        loginExt = in.readString();

        appKey = in.readString();
        customClientType = in.readInt();
    }

    public static final Creator<LoginInfo> CREATOR = new Creator<LoginInfo>() {
        @Override
        public LoginInfo createFromParcel(Parcel in) {
            return new LoginInfo(in);
        }

        @Override
        public LoginInfo[] newArray(int size) {
            return new LoginInfo[size];
        }
    };

    /**
     * 用户账号，对应云信 IM 账号 accid。
     */
    public String getAccount() {
        return account;
    }

    /**
     * 登录 token。
     */
    public String getToken() {
        return token;
    }

    /**
     * SDK 登录 IM 的鉴权方式。
     * <ul><li>0（默认）：表示最初的 loginToken的校验方式，即通过静态 token 鉴权。</li>
     * <li>1：表示基于 appSecret 计算的 token 鉴权方式，即通过动态 token 鉴权。</li>
     * <li>2：表示基于第三方回调的 token 鉴权方式，使用该方式时，登录信息中必须传入自定义扩展字段。</li></ul>
     */
    public int getAuthType() {
        return authType;
    }

    /**
     * 登录自定义扩展字段，用于第三方服务器鉴权。当 authType 为 2 时，必须传入该字段。
     */
    public String getLoginExt() {
        return loginExt;
    }

    /**
     * 当前应用的 AppKey。
     */
    public String getAppKey() {
        return appKey;
    }

    /**
     * 自定义客户端类型，对应云信控制台中的自定义终端类型（需提前在控制台添加）。小于等于 0 视为没有自定义类型。
     */
    public int getCustomClientType() {
        return customClientType;
    }

    /**
     * 检查用户登录信息，验证该用户是否已存在，该用户信息是否有效。
     *
     * @return 是否有效
     */
    public boolean valid() {
        if (authType == IAuthService.AuthType.DEFAULT) {
            return !TextUtils.isEmpty(account) && !TextUtils.isEmpty(token);
        } else {
            return !TextUtils.isEmpty(account);
        }
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        LoginInfo loginInfo = (LoginInfo) o;
        return authType == loginInfo.authType &&
                customClientType == loginInfo.customClientType &&
                Objects.equals(account, loginInfo.account) &&
                Objects.equals(token, loginInfo.token) &&
                Objects.equals(loginExt, loginInfo.loginExt) &&
                Objects.equals(appKey, loginInfo.appKey);
    }


    @NonNull
    @Override
    public String toString() {
        return "LoginInfo{" +
                "account='" + account + '\'' +
                ", authType=" + authType +
                ", customClientType=" + customClientType +
                '}';
    }

    @Override
    public int hashCode() {
        return Objects.hash(account, token, authType, loginExt, appKey, customClientType);
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(account);
        dest.writeString(token);

        dest.writeInt(authType);
        dest.writeString(loginExt);

        dest.writeString(appKey);
        dest.writeInt(customClientType);
    }

    public JSONObject toJson() {
        JSONObject object = new JSONObject();
        try {
            object.putOpt(KEY_ACCOUNT, account);
            object.putOpt(KEY_TOKEN, token);
            object.putOpt(KEY_AUTH_TYPE, authType);
            object.putOpt(KEY_LOGIN_EXT, loginExt);
            object.putOpt(KEY_APP_KEY, appKey);
            object.putOpt(KEY_CUSTOM_CLIENT_TYPE, customClientType);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return object;
    }

    public static LoginInfo fromJson(JSONObject object) {
        if (object == null) {
            return null;
        }

        final String account = object.optString(KEY_ACCOUNT, null);
        final String token = object.optString(KEY_TOKEN, null);
        final int authType = object.optInt(KEY_AUTH_TYPE);
        final String loginExt = object.optString(KEY_LOGIN_EXT, null);
        final String appKey = object.optString(KEY_APP_KEY, null);
        final int customClientType = object.optInt(KEY_CUSTOM_CLIENT_TYPE);

        return new LoginInfoBuilder(account, token, authType, loginExt).withAppKey(appKey).withCustomClientType(customClientType).build();
    }


    public static final class LoginInfoBuilder {
        private String account;
        private String token;

        private int authType;
        private String loginExt;

        private String appKey;
        private int customClientType;

        public LoginInfoBuilder(String account, String token, int authType, String loginExt) {
            this.account = account;
            this.token = token;

            this.authType = authType;
            this.loginExt = loginExt;
        }

        public static LoginInfoBuilder loginInfoDefault(String account, String token) {
            return new LoginInfoBuilder(account, token, IAuthService.AuthType.DEFAULT, "");
        }

        public static LoginInfoBuilder loginInfoDynamic(String account, String token) {
            return new LoginInfoBuilder(account, token, IAuthService.AuthType.DYNAMIC, "");
        }

        public static LoginInfoBuilder loginInfoThirdParty(String account, String token, String loginExt) {
            return new LoginInfoBuilder(account, token, IAuthService.AuthType.THIRDPARTY, loginExt);
        }

        public static LoginInfoBuilder loginInfoThirdPartyDynamic(String account, String token) {
            return new LoginInfoBuilder(account, token, IAuthService.AuthType.THIRDPARTY, "");
        }

        public LoginInfoBuilder withAppKey(String appKey) {
            this.appKey = appKey;
            return this;
        }

        public LoginInfoBuilder withCustomClientType(int customClientType) {
            this.customClientType = customClientType;
            return this;
        }

        public LoginInfoBuilder withAuthType(int authType) {
            this.authType = authType;
            return this;
        }

        public LoginInfoBuilder withLoginExt(String loginExt) {
            this.loginExt = loginExt;
            return this;
        }

        public LoginInfo build() {
            LoginInfo loginInfo = new LoginInfo(account, token);

            loginInfo.authType = this.authType;
            loginInfo.loginExt = this.loginExt;

            loginInfo.appKey = this.appKey;
            loginInfo.customClientType = this.customClientType;
            return loginInfo;
        }
    }
}