xDrip+ v04633772025.07.16 - TidepoolUploader.java 源代码

package com.eveningoutpost.dexdrip.tidepool;

import android.os.PowerManager;
import com.eveningoutpost.dexdrip.models.JoH;
import com.eveningoutpost.dexdrip.models.UserError;
import com.eveningoutpost.dexdrip.store.FastStore;
import com.eveningoutpost.dexdrip.utilitymodels.OkHttpWrapper;
import com.eveningoutpost.dexdrip.utilitymodels.Pref;
import java.util.List;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.RequestBody;
import okhttp3.logging.HttpLoggingInterceptor;
import retrofit2.Call;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;
import retrofit2.http.Body;
import retrofit2.http.DELETE;
import retrofit2.http.GET;
import retrofit2.http.Header;
import retrofit2.http.Headers;
import retrofit2.http.POST;
import retrofit2.http.PUT;
import retrofit2.http.Path;
import retrofit2.http.Query;

public class TidepoolUploader {
    private static final boolean D = true;
    private static final String INTEGRATION_BASE_URL = "https://int-api.tidepool.org";
    private static final String PRODUCTION_BASE_URL = "https://api.tidepool.org";
    private static final boolean REPEAT = false;
    private static final String SESSION_TOKEN_HEADER = "x-tidepool-session-token";
    protected static final String STATUS_KEY = "Tidepool-Status";
    protected static final String TAG = "TidepoolUploader";
    private static Retrofit retrofit;
    private static PowerManager.WakeLock wl;

    public interface Tidepool {
        @PUT("/v1/datasets/{sessionId}")
        Call<MDatasetReply> closeDataSet(@Header("x-tidepool-session-token") String str, @Path("sessionId") String str2, @Body RequestBody requestBody);

        @DELETE("/v1/users/{userId}/data")
        Call<MDatasetReply> deleteAllData(@Header("x-tidepool-session-token") String str, @Path("userId") String str2);

        @DELETE("/v1/datasets/{dataSetId}")
        Call<MDatasetReply> deleteDataSet(@Header("x-tidepool-session-token") String str, @Path("dataSetId") String str2);

        @POST("/v1/datasets/{sessionId}/data")
        Call<MUploadReply> doUpload(@Header("x-tidepool-session-token") String str, @Path("sessionId") String str2, @Body RequestBody requestBody);

        @GET("/v1/datasets/{dataSetId}")
        Call<MDatasetReply> getDataSet(@Header("x-tidepool-session-token") String str, @Path("dataSetId") String str2);

        @Headers({"User-Agent: xDrip+ 0463377-2025.07.16", "X-Tidepool-Client-Name: com.eveningoutpost.dexdrip", "X-Tidepool-Client-Version: 0.1.0"})
        @POST("/auth/login")
        Call<MAuthReply> getLogin(@Header("Authorization") String str);

        @GET("/v1/users/{userId}/data_sets")
        Call<List<MDatasetReply>> getOpenDataSets(@Header("x-tidepool-session-token") String str, @Path("userId") String str2, @Query("client.name") String str3, @Query("size") int i);

        @POST("/v1/users/{userId}/data_sets")
        Call<MDatasetReply> openDataSet(@Header("x-tidepool-session-token") String str, @Path("userId") String str2, @Body RequestBody requestBody);
    }

    public static String getSESSION_TOKEN_HEADER() {
        return SESSION_TOKEN_HEADER;
    }

    public static Retrofit getRetrofitInstance() {
        if (retrofit == null) {
            HttpLoggingInterceptor httpLoggingInterceptor = new HttpLoggingInterceptor();
            httpLoggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
            retrofit = new Retrofit.Builder().baseUrl(Pref.getBooleanDefaultFalse("tidepool_dev_servers") ? INTEGRATION_BASE_URL : PRODUCTION_BASE_URL).client(OkHttpWrapper.enableTls12OnPreLollipop(new OkHttpClient.Builder()).addInterceptor(httpLoggingInterceptor).addInterceptor(new InfoInterceptor(TAG)).build()).addConverterFactory(GsonConverterFactory.create()).build();
        }
        return retrofit;
    }

    public static void resetInstance() {
        retrofit = null;
        AuthFlowOut.clearAllSavedData();
        UserError.Log.d(TAG, "Instance reset");
    }

    public static void doLoginFromUi() {
        doLogin(D);
    }

    public static synchronized void doLogin(boolean z) {
        synchronized (TidepoolUploader.class) {
            if (!TidepoolEntry.enabled()) {
                UserError.Log.d(TAG, "Cannot login as disabled by preference");
                if (z) {
                    JoH.static_toast_long("Cannot login as Tidepool feature not enabled");
                }
            } else {
                if (JoH.ratelimit("tidepool-login", 10)) {
                    extendWakeLock(30000L);
                    AuthFlowIn.handleTokenLoginAndStartSession();
                }
            }
        }
    }

    private static void loginFailed(boolean z) {
        if (z) {
            JoH.static_toast_long("Login failed - see event log for details");
        }
        releaseWakeLock();
    }

    public static void startSession(final Session session, final boolean z) {
        if (JoH.ratelimit("tidepool-start-session", 60)) {
            extendWakeLock(30000L);
            String str = session.authReply.userid;
            if (str != null) {
                session.service.getOpenDataSets(session.token, str, "com.eveningoutpost.dexdrip", 1).enqueue(new TidepoolCallback(session, "Get Open Datasets", new Runnable() {
                    @Override
                    public final void run() {
                        TidepoolUploader.lambda$startSession$1(Session.this, z);
                    }
                }).setOnFailure(new TidepoolUploader$$ExternalSyntheticLambda2()));
                return;
            }
            UserError.Log.wtf(TAG, "Got login response but cannot determine userid - cannot proceed");
            if (z) {
                JoH.static_toast_long("Error: Cannot determine userid");
            }
            status("Error userid");
            releaseWakeLock();
            return;
        }
        status("Cool Down Wait");
        if (z) {
            JoH.static_toast_long("In cool down period, please wait 1 minute");
        }
    }

    public static void lambda$startSession$1(final Session session, boolean z) {
        if (session.datasetReply == null) {
            status("New data set");
            if (z) {
                JoH.static_toast_long("Creating new data set - all good");
            }
            session.service.openDataSet(session.token, session.authReply.userid, new MOpenDatasetRequest().getBody()).enqueue(new TidepoolCallback(session, "Open New Dataset", new Runnable() {
                @Override
                public final void run() {
                    TidepoolUploader.doUpload(Session.this);
                }
            }).setOnFailure(new TidepoolUploader$$ExternalSyntheticLambda2()));
            return;
        }
        UserError.Log.d(TAG, "Existing Dataset: " + session.datasetReply.getUploadId());
        status("Appending");
        if (z) {
            JoH.static_toast_long("Found existing remote data set - all good");
        }
        doUpload(session);
    }

    public static void doUpload(final Session session) {
        if (!TidepoolEntry.enabled()) {
            UserError.Log.e(TAG, "Cannot upload - preference disabled");
            return;
        }
        extendWakeLock(60000L);
        session.iterations++;
        String next = UploadChunk.getNext(session);
        if (next != null) {
            if (next.length() == 2) {
                UserError.Log.d(TAG, "Empty data set - marking as succeeded");
                doCompleted(session);
                return;
            } else {
                Call<MUploadReply> doUpload = session.service.doUpload(session.token, session.datasetReply.getUploadId(), RequestBody.create(MediaType.parse("application/json"), next));
                status("Uploading");
                doUpload.enqueue(new TidepoolCallback(session, "Data Upload", new Runnable() {
                    @Override
                    public final void run() {
                        TidepoolUploader.lambda$doUpload$3(Session.this);
                    }
                }).setOnFailure(new TidepoolUploader$$ExternalSyntheticLambda2()));
                return;
            }
        }
        UserError.Log.e(TAG, "Upload chunk is null, cannot proceed");
        releaseWakeLock();
    }

    public static void lambda$doUpload$3(Session session) {
        UploadChunk.setLastEnd(session.end);
        if (MOpenDatasetRequest.isNormal()) {
            doClose(session);
        } else {
            doCompleted(session);
        }
    }

    private static void doClose(Session session) {
        status("Closing");
        extendWakeLock(20000L);
        session.service.closeDataSet(session.token, session.datasetReply.getUploadId(), new MCloseDatasetRequest().getBody()).enqueue(new TidepoolCallback(session, "Session Stop", new Runnable() {
            @Override
            public final void run() {
                TidepoolUploader.closeSuccess();
            }
        }));
    }

    public static void closeSuccess() {
        status("Closed");
        UserError.Log.d(TAG, "Close success");
        releaseWakeLock();
    }

    private static void doCompleted(Session session) {
        status("Completed OK");
        UserError.Log.d(TAG, "ALL COMPLETED OK!");
        releaseWakeLock();
    }

    private static void status(String str) {
        FastStore.getInstance().putS(STATUS_KEY, str);
    }

    private static synchronized void extendWakeLock(long j) {
        synchronized (TidepoolUploader.class) {
            PowerManager.WakeLock wakeLock = wl;
            if (wakeLock == null) {
                wl = JoH.getWakeLock("tidepool-uploader", (int) j);
            } else {
                JoH.releaseWakeLock(wakeLock);
                wl.acquire(j);
            }
        }
    }

    protected static synchronized void releaseWakeLock() {
        synchronized (TidepoolUploader.class) {
            UserError.Log.d(TAG, "Releasing wakelock");
            JoH.releaseWakeLock(wl);
        }
    }

    private static void deleteData(Session session) {
        String str = session.authReply.userid;
        if (str != null) {
            session.service.deleteAllData(session.token, str).enqueue(new TidepoolCallback(session, "Delete Data", null));
        } else {
            UserError.Log.wtf(TAG, "Got login response but cannot determine userid - cannot proceed");
        }
    }

    private static void getDataSet(Session session) {
        session.service.getDataSet(session.token, "bogus").enqueue(new TidepoolCallback(session, "Get Data", null));
    }

    private static void deleteDataSet(Session session) {
        session.service.deleteDataSet(session.token, "bogus").enqueue(new TidepoolCallback(session, "Delete Data", null));
    }
}