GaliciaActivity.java

package ar.com.galicia.core.services;

import android.content.Intent;

import com.facebook.stetho.okhttp3.StethoInterceptor;
import com.google.firebase.analytics.FirebaseAnalytics;
import com.google.firebase.crashlytics.FirebaseCrashlytics;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

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

import java.util.Locale;
import java.util.Objects;
import java.util.UUID;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

import ar.com.galicia.Env;
import ar.com.galicia.SslBehaviours;
import ar.com.galicia.core.GaliciaApplication;
import ar.com.galicia.core.GaliciaConstants;
import ar.com.galicia.core.tag.EventManagerNA;
import ar.com.galicia.session.managers.SessionHandler;
import ar.com.galicia.session.managers.SessionManager;
import ar.com.galicia.core.activities.GaliciaActivity;
import ar.com.galicia.core.activities.MantenimientoActivity;
import ar.com.galicia.core.activities.SplashActivity;
import ar.com.galicia.core.cache.CacheManager;
import ar.com.galicia.core.cache.CacheManagerKey;
import ar.com.galicia.core.rsa.RsaHelper;
import ar.com.galicia.core.utils.GaliciaUtils;
import ar.com.galicia.login.entitties.User;
import ar.com.galicia.session.initializations.InitializationService;
import okhttp3.Dispatcher;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.ResponseBody;
import okhttp3.logging.HttpLoggingInterceptor;
import retrofit2.Retrofit;
import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory;
import retrofit2.converter.gson.GsonConverterFactory;

@Deprecated
/**
 * Usar
 * @see GaliciaServiceCall
 */
public class GaliciaServices implements GaliciaConstants {
    private static GaliciaActivity galiciaActivity;
    private static Retrofit retrofit;
    private static OkHttpClient.Builder httpClientBuilder;
    private static Gson gson;

    /**
     * Crea una instancia de GaliciaService con un objecto GaliciaActivity
     *
     * @deprecated Usar GaliciaServiceCall.instance(Class) la cual no requiere un objecto GaliciaActivity.
     */
    @Deprecated
    public static <S> S instance(final GaliciaActivity actividad, final Class<S> serviceClass) {
        return GaliciaServices.instance(actividad, serviceClass, false);
    }

    /**
     * Crea una instancia de GaliciaService con un objecto GaliciaActivity
     *
     * @deprecated Usar GaliciaServiceCall.smpInstance(Class) la cual no requiere un objecto GaliciaActivity.
     */
    @Deprecated
    public static <S> S smpInstance(final GaliciaActivity actividad, final Class<S> serviceClass) {
        GaliciaServices.resetRetrofit();
        S inst = GaliciaServices.instance(actividad, serviceClass, true);
        GaliciaServices.resetRetrofit();
        return inst;
    }

    /**
     * Crea una instancia de GaliciaService con un objecto GaliciaActivity
     *
     * @deprecated Usar GaliciaServiceCall.instance(Class, boolean) la cual no requiere un objecto GaliciaActivity.
     */
    @Deprecated
    private static <S> S instance(final GaliciaActivity actividad, final Class<S> serviceClass, final boolean isSMP) {
        GaliciaServices.galiciaActivity = actividad;
        if (retrofit == null || !retrofit.baseUrl().equals(GaliciaServices.getEndPoint(isSMP))) {
            httpClientBuilder = SslBehaviours.getHttpClientBuilder();
            // Estos son interceptores de salida--> Modifican el request
            httpClientBuilder.addInterceptor(chain -> {
                Request original = chain.request();
                Request.Builder requestBuilder = original.newBuilder();
                if (User.getInstance().getToken() != null && !User.getInstance().getToken().isEmpty()) {
                    requestBuilder.header("tokenkey", User.getInstance().getToken());
                }
                requestBuilder.header("ChannelType", "Mobile");
                if (User.getInstance().getCsrfToken() != null && !User.getInstance().getCsrfToken().equals("undefined")) {
                    requestBuilder.header("x-csrf-token", User.getInstance().getCsrfToken());
                }
                requestBuilder.header("LocationLongitude", CacheManager.getString(CacheManagerKey.Key.Loc_longitud));
                requestBuilder.header("LocationLatitude", CacheManager.getString(CacheManagerKey.Key.Loc_latitud));
                requestBuilder.header("GaliciaId", GALICIA_ID);
                requestBuilder.header("ChannelId", CHANNEL_ID);
                requestBuilder.header("DeviceIpAddress", CacheManager.getString(CacheManagerKey.Key.IPAddress));
                requestBuilder.header("DeviceName", GaliciaUtilService.getDeviceName());
                requestBuilder.header("DeviceId", CacheManager.getString(CacheManagerKey.Key.SoftLoginSMPDeviceId));
                requestBuilder.header("InternalOrganizationId", INTERNAL_ORGANIZATION_ID);
                requestBuilder.header("InternalOrganizationType", INTERNAL_ORGANIZATION_TYPE);
                requestBuilder.header("AppVersion", GaliciaUtilService.getCurrentVersion());
                requestBuilder.header("AppPlatform", APP_PLATFORM);
                requestBuilder.header("AdaptiveTokenCookie", CacheManager.getString(CacheManagerKey.Key.AdaptiveCookie));
                requestBuilder.header("Language", Locale.getDefault().getLanguage());
                requestBuilder.header("Country", Locale.getDefault().getCountry());

                String rsaHeader = RsaHelper.getInstance().getCurrentMobileApiInfo();
                if (rsaHeader != null && !rsaHeader.isEmpty()) {
                    String rsaEncryptedHeader = GaliciaUtils.encodeBase64(rsaHeader);
                    requestBuilder.header("adaptivefingerprint", rsaEncryptedHeader);
                }

                requestBuilder.header("MessageUUI", UUID.randomUUID().toString().replaceAll("-", ""));

                Request request = requestBuilder.build();

                return chain.proceed(request);
            });

            Dispatcher dispatcher = new Dispatcher();
            httpClientBuilder.dispatcher(dispatcher);

            // add your other interceptors …
            httpClientBuilder.addInterceptor(chain -> {
                try {
                    Request original = chain.request();
                    Response response = chain.proceed(original);
                    guardarCookieAdaptive(response);
                    resetearTiempoDeSesion(response);

                    if (!response.isSuccessful()) {
                        ResponseBody responseBody = response.peekBody(Long.MAX_VALUE);
                        if (galiciaActivity != null) {
                            if (esHachaDeCorte(response)) {
                                mostrarPantallaHachaDeCorte();
                            }
                            if (esSesionVencida(responseBody)) {
                                dispatcher.cancelAll();
                                cerrarSesion(actividad);
                                JSONObject jsonObject = new JSONObject();
                                try {
                                    jsonObject.put("code", 400);
                                    jsonObject.put("status", "UAF");
                                    jsonObject.put("message", "SessionClosed");

                                    MediaType contentType = response.body().contentType();
                                    ResponseBody body = ResponseBody.create(contentType, String.valueOf(jsonObject));
                                    return response.newBuilder().body(body).build();
                                } catch (JSONException e) {
                                    e.printStackTrace();
                                }
                            }
                        }
                    }
                    return response;

                } catch (Exception exception) {
                    FirebaseCrashlytics.getInstance().log("ERROR EN REQUEST(D)");
                    //FirebaseCrashlytics.getInstance().log(Objects.requireNonNull(chain.request().url().query()));
                    FirebaseCrashlytics.getInstance().recordException(exception);
                    dispatcher.cancelAll();
                    GaliciaActivity.mostrarSinConexionDialogFragment();
                    SessionManager.getInstance().cleanSession();
                    EventManagerNA.setLogOutUserId();
                    exception.printStackTrace();
                    throw exception;
                }
            });

            httpClientBuilder.addNetworkInterceptor(new StethoInterceptor());

            //LOGGING INTERCEPTOR (INDISPENSABLE!!!!!!!)---------------------------------------------
            //Sirve para loggear en Android Studio los request y response con backend (Evita el uso de StethoInterceptor)
            HttpLoggingInterceptor logging = new HttpLoggingInterceptor();

            // set your desired log level
            logging.setLevel(HttpLoggingInterceptor.Level.BODY);

            // add logging as last interceptor
            httpClientBuilder.addInterceptor(logging);// <-- this is the important line!

            httpClientBuilder.connectTimeout(30, TimeUnit.SECONDS).readTimeout(30, TimeUnit.SECONDS).writeTimeout(8000, TimeUnit.SECONDS);
            gson = new GsonBuilder()
                    .setDateFormat("yyyy-MM-dd'T'HH:mm:ssZ")
                    .registerTypeHierarchyAdapter(java.util.List.class, new GaliciaResponseDeserializer())
                    .create();
            Retrofit.Builder retrofitBuilder = new Retrofit.Builder()
                    .baseUrl(GaliciaServices.getEndPoint(isSMP))
                    .addConverterFactory(GsonConverterFactory.create(gson))
                    .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                    .client(httpClientBuilder.build())
                    .callbackExecutor(Executors.newFixedThreadPool(1));
            retrofit = retrofitBuilder.build();
        }
        return retrofit.create(serviceClass);
    }

    public static String getEndPoint(final boolean isSMP) {
        if (isSMP) {
            return Env.getSMPEndPoint();
        }
        return Env.getEndPoint();
    }

    public static void resetRetrofit() {
        retrofit = null;
    }

    private static void resetearTiempoDeSesion(Response response) {
        if (!response.request().url().toString().contains("/odata/ns/")) {
            SessionHandler.getInstance().setTimeInSession(System.currentTimeMillis());
        }
    }

    private static void guardarCookieAdaptive(Response response) {
        String adaptiveCookie = buscarHeaderAdaptive(response);
        if (adaptiveCookie != null && !adaptiveCookie.isEmpty()) {
            CacheManager.addString(CacheManagerKey.Key.AdaptiveCookie, adaptiveCookie);
        }
    }

    private static void cerrarSesion(GaliciaActivity activity) {
        SessionHandler mSessionHandler = SessionHandler.getInstance();
        mSessionHandler.setComesFromLogout(true);
        mSessionHandler.closeApp(activity);
    }

    private static boolean esSesionVencida(ResponseBody responseBody) {
        GaliciaError error = ServiceErrorExtractor.getErrorMessage(responseBody);
        return error.isSessionExpired();
    }

    private static void mostrarPantallaHachaDeCorte() {
        if (galiciaActivity != null) {
            galiciaActivity.runOnUiThread(() -> {
                if (!galiciaActivity.isFinishing()) {
                    if (InitializationService.muestroMantenimeinto) {
                        InitializationService.muestroMantenimeinto = false;
                        Intent intent = new Intent(galiciaActivity, MantenimientoActivity.class);
                        galiciaActivity.startActivity(intent);
                    }
                } else {
                    Intent intent = new Intent(galiciaActivity, SplashActivity.class);
                    galiciaActivity.startActivity(intent);
                }
            });
        }
    }

    private static boolean esHachaDeCorte(Response response) {
        try {
            return Objects.requireNonNull(response.headers().get("x-sap-icm-err-id")).equalsIgnoreCase("ICMENOSERVERFOUND");
        } catch (Exception ex) {
            return false;
        }
    }

    private static String buscarHeaderAdaptive(Response Response) {
        String hearderConMinusculas = Response.header("adaptivetokencookie");
        String hearderConCapitalCase = Response.header("AdaptiveTokenCookie");
        String hearderConCamelCase = Response.header("adaptiveTokenCookie");
        if (hearderConCapitalCase != null && !hearderConCapitalCase.isEmpty()) {
            return hearderConCapitalCase;
        }
        if (hearderConMinusculas != null && !hearderConMinusculas.isEmpty()) {
            return hearderConMinusculas;
        }
        if (hearderConCamelCase != null && !hearderConCamelCase.isEmpty()) {
            return hearderConCamelCase;
        }
        return "";
    }

}