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

package com.eveningoutpost.dexdrip;

import android.animation.ValueAnimator;
import android.annotation.SuppressLint;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.PendingIntent;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.graphics.Color;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.net.Uri;
import android.os.Bundle;
import android.os.PowerManager;
import android.util.Log;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.Window;
import android.view.animation.AccelerateInterpolator;
import android.view.animation.DecelerateInterpolator;
import android.view.animation.Interpolator;
import android.view.inputmethod.InputMethodManager;
import android.widget.CheckBox;
import android.widget.EditText;
import android.widget.RadioButton;
import android.widget.RelativeLayout;
import android.widget.TextView;
import androidx.cardview.widget.CardView;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import androidx.health.platform.client.error.ErrorCode;
import androidx.recyclerview.widget.RecyclerView;
import com.eveningoutpost.dexdrip.ActivityWithRecycler;
import com.eveningoutpost.dexdrip.models.JoH;
import com.eveningoutpost.dexdrip.models.Reminder;
import com.eveningoutpost.dexdrip.models.Treatments;
import com.eveningoutpost.dexdrip.models.UserError;
import com.eveningoutpost.dexdrip.profileeditor.DatePickerFragment;
import com.eveningoutpost.dexdrip.profileeditor.ProfileAdapter;
import com.eveningoutpost.dexdrip.profileeditor.TimePickerFragment;
import com.eveningoutpost.dexdrip.receiver.ReminderReceiver;
import com.eveningoutpost.dexdrip.utilitymodels.JamorhamShowcaseDrawer;
import com.eveningoutpost.dexdrip.utilitymodels.PersistentStore;
import com.eveningoutpost.dexdrip.utilitymodels.Pref;
import com.eveningoutpost.dexdrip.utilitymodels.ShotStateStore;
import com.eveningoutpost.dexdrip.utilitymodels.SpeechUtil;
import com.eveningoutpost.dexdrip.utils.HomeWifi;
import com.github.amlcurran.showcaseview.OnShowcaseEventListener;
import com.github.amlcurran.showcaseview.R$dimen;
import com.github.amlcurran.showcaseview.ShowcaseView;
import com.github.amlcurran.showcaseview.targets.ViewTarget;
import com.rits.cloning.Cloner;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.atomic.AtomicBoolean;

public class Reminders extends ActivityWithRecycler implements SensorEventListener {
    private static volatile boolean proximity = true;
    private AlertDialog dialog;
    private View dialogView;
    private TextView floaterText;
    private CardView floatingsnooze;
    private Reminder last_swiped;
    private Reminder last_undo;
    private Sensor mProximity;
    private SensorManager mSensorManager;
    private EditText reminderDaysEdt;
    MenuItem remindersAdvancedMenuItem;
    MenuItem remindersCancelByDefaultMenuItem;
    MenuItem remindersDisabledAtNightMenuItem;
    MenuItem remindersDisabledMenuItem;
    MenuItem remindersRestartTomorrowMenuItem;
    private String selectedSound;
    private TextView swipePromptText;
    public final List<Reminder> reminders = new ArrayList();
    private boolean floaterHidden = true;
    private long default_snooze = 1800000;
    private int proximity_events = 0;
    private int highlighted = 0;

    @Override
    public void onAccuracyChanged(Sensor sensor, int i) {
    }

    static int access$308(Reminders reminders) {
        int i = reminders.highlighted;
        reminders.highlighted = i + 1;
        return i;
    }

    @Override
    protected void onCreate(Bundle bundle) {
        super.onCreate(bundle);
        setContentView(2131492935);
        setTheme(2131820554);
        JoH.fixActionBar(this);
        setTitle(getString(2131757067));
        this.recyclerView = (RecyclerView) findViewById(2131296900);
        this.floatingsnooze = (CardView) findViewById(2131296622);
        this.floaterText = (TextView) findViewById(2131296621);
        this.swipePromptText = (TextView) findViewById(2131296911);
        this.floatingsnooze.setVisibility(8);
        SensorManager sensorManager = (SensorManager) getSystemService("sensor");
        this.mSensorManager = sensorManager;
        this.mProximity = sensorManager.getDefaultSensor(8);
        this.mAdapter = new RecyclerAdapter(this, this.reminders);
        if (this.selectedSound == null && PersistentStore.getString("reminders-last-sound").length() > 5) {
            this.selectedSound = PersistentStore.getString("reminders-last-sound");
        }
        reloadList();
        postOnCreate();
        processIncomingBundle(getIntent().getExtras());
        if (this.reminders.size() == 0) {
            showcase(this, 14);
        }
    }

    @Override
    public void onNewIntent(Intent intent) {
        processIncomingBundle(intent.getExtras());
    }

    public void onRemindNightClick(MenuItem menuItem) {
        invertPreferenceBoolean(Reminder.REMINDERS_NIGHT_DISABLED);
        updateMenuCheckboxes();
    }

    public void onAllDisabledClick(MenuItem menuItem) {
        invertPreferenceBoolean(Reminder.REMINDERS_ALL_DISABLED);
        updateMenuCheckboxes();
    }

    public void onCancelByDefaultClick(MenuItem menuItem) {
        invertPreferenceBoolean(Reminder.REMINDERS_CANCEL_DEFAULT);
        updateMenuCheckboxes();
    }

    public void onRestartTomorrowClick(MenuItem menuItem) {
        invertPreferenceBoolean(Reminder.REMINDERS_RESTART_TOMORROW);
        updateMenuCheckboxes();
    }

    public void onRemindersAdvancedClick(MenuItem menuItem) {
        invertPreferenceBoolean(Reminder.REMINDERS_ADVANCED_MODE);
        updateMenuCheckboxes();
    }

    public void onRemindersHomeNetworkClick(MenuItem menuItem) {
        HomeWifi.ask(this);
    }

    private void invertPreferenceBoolean(String str) {
        Pref.setBoolean(str, !Pref.getBooleanDefaultFalse(str));
    }

    private void updateMenuCheckboxes() {
        this.remindersAdvancedMenuItem.setChecked(Pref.getBooleanDefaultFalse(Reminder.REMINDERS_ADVANCED_MODE));
        this.remindersDisabledMenuItem.setChecked(Pref.getBooleanDefaultFalse(Reminder.REMINDERS_ALL_DISABLED));
        this.remindersRestartTomorrowMenuItem.setChecked(Pref.getBooleanDefaultFalse(Reminder.REMINDERS_RESTART_TOMORROW));
        this.remindersDisabledAtNightMenuItem.setChecked(Pref.getBooleanDefaultFalse(Reminder.REMINDERS_NIGHT_DISABLED));
        this.remindersRestartTomorrowMenuItem.setEnabled(this.remindersDisabledMenuItem.isChecked());
        this.remindersCancelByDefaultMenuItem.setChecked(Pref.getBooleanDefaultFalse(Reminder.REMINDERS_CANCEL_DEFAULT));
    }

    private void handleSwipePromptVisibility() {
        if (this.reminders.size() > 0) {
            this.swipePromptText.setVisibility(0);
        } else {
            this.swipePromptText.setVisibility(8);
        }
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(2131558412, menu);
        this.remindersDisabledAtNightMenuItem = menu.findItem(2131296907);
        this.remindersDisabledMenuItem = menu.findItem(2131296909);
        this.remindersRestartTomorrowMenuItem = menu.findItem(2131296913);
        this.remindersAdvancedMenuItem = menu.findItem(2131296906);
        this.remindersCancelByDefaultMenuItem = menu.findItem(2131296908);
        updateMenuCheckboxes();
        return super.onCreateOptionsMenu(menu);
    }

    @Override
    protected void onResume() {
        JoH.getWakeLock("reminders-onresume", 15000);
        super.onResume();
        if (JoH.ratelimit("proximity-reset", 5)) {
            Log.d("Reminders", "Initializing proximity as true");
            proximity = true;
        }
        this.proximity_events = 0;
        this.mSensorManager.registerListener(this, this.mProximity, 3);
        this.highlighted = 0;
        reloadList();
        handleSwipePromptVisibility();
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.d("Reminders", "onPause");
        JoH.runOnUiThreadDelayed(new Runnable() {
            @Override
            public void run() {
                Log.d("Reminders", "Unregistering proximity sensor listener");
                try {
                    Reminders.this.mSensorManager.unregisterListener(this);
                } catch (Exception e) {
                    Log.d("Reminders", "Error unregistering proximity listener: " + e);
                }
            }
        }, 10000L);
    }

    @Override
    public void onSensorChanged(SensorEvent sensorEvent) {
        if (sensorEvent.sensor.getType() == 8) {
            int i = this.proximity_events + 1;
            this.proximity_events = i;
            if (i < 20) {
                Log.d("Reminders", "Sensor: " + sensorEvent.values[0] + " " + this.mProximity.getMaximumRange());
            }
            if (sensorEvent.values[0] <= Math.min(this.mProximity.getMaximumRange() / 2.0f, 10.0f)) {
                proximity = true;
            } else {
                proximity = false;
            }
            if (this.proximity_events < 20) {
                Log.d("Reminders", "Proxmity set to: " + proximity);
            }
        }
    }

    private void reloadList() {
        this.reminders.clear();
        this.reminders.addAll(Reminder.getAllReminders());
        this.mAdapter.notifyDataSetChanged();
    }

    public class MyViewHolder extends ActivityWithRecycler.MyViewHolder {
        TextView next_due_text;
        TextView small_text;
        EditText title_text;
        RelativeLayout wholeBlock;

        public MyViewHolder(View view) {
            super(view);
            this.small_text = (TextView) view.findViewById(2131296901);
            this.title_text = (EditText) view.findViewById(2131296903);
            this.next_due_text = (TextView) view.findViewById(2131296912);
            this.wholeBlock = (RelativeLayout) view.findViewById(2131296904);
        }
    }

    public class RecyclerAdapter extends ActivityWithRecycler.RecyclerAdapater {
        public RecyclerAdapter(Context context, List<Reminder> list) {
            super();
            Log.d("Reminders", "New adapter, size: " + list.size());
        }

        @Override
        public int getItemCount() {
            return Reminders.this.reminders.size();
        }

        @Override
        public ActivityWithRecycler.MyViewHolder onCreateViewHolder(ViewGroup viewGroup, int i) {
            final MyViewHolder myViewHolder = Reminders.this.new MyViewHolder(LayoutInflater.from(viewGroup.getContext()).inflate(2131493069, viewGroup, false));
            myViewHolder.title_text.setOnEditorActionListener(new TextView.OnEditorActionListener() {
                @Override
                public boolean onEditorAction(TextView textView, int i2, KeyEvent keyEvent) {
                    if (i2 != 6) {
                        return false;
                    }
                    int adapterPosition = myViewHolder.getAdapterPosition();
                    Reminders.this.reminders.get(adapterPosition).updateTitle(myViewHolder.title_text.getText().toString());
                    RecyclerAdapter.this.notifyItemChanged(adapterPosition);
                    return false;
                }
            });
            myViewHolder.title_text.setOnLongClickListener(new View.OnLongClickListener() {
                @Override
                public boolean onLongClick(View view) {
                    Reminders reminders = Reminders.this;
                    reminders.showReminderDialog(null, reminders.reminders.get(myViewHolder.getAdapterPosition()), 0);
                    return false;
                }
            });
            myViewHolder.next_due_text.setOnLongClickListener(new View.OnLongClickListener() {
                @Override
                public boolean onLongClick(View view) {
                    Reminders reminders = Reminders.this;
                    reminders.showReminderDialog(null, reminders.reminders.get(myViewHolder.getAdapterPosition()), 0);
                    return false;
                }
            });
            myViewHolder.small_text.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    Reminders.this.askTime(myViewHolder.getAdapterPosition());
                }
            });
            return myViewHolder;
        }

        @Override
        public void onBindViewHolder(ActivityWithRecycler.MyViewHolder myViewHolder, @SuppressLint({"RecyclerView"}) int i) {
            String str;
            String str2;
            String str3;
            String str4;
            MyViewHolder myViewHolder2 = (MyViewHolder) myViewHolder;
            Reminder reminder = Reminders.this.reminders.get(i);
            myViewHolder2.position = i;
            myViewHolder2.title_text.setText(reminder.getTitle());
            String str5 = "";
            if (reminder.fired_times > 0) {
                if (JoH.msSince(reminder.last_fired) < 86400000) {
                    str4 = "" + xdrip.getAppContext().getString(2131755736) + " " + JoH.hourMinuteString(reminder.last_fired);
                } else {
                    str4 = "" + xdrip.getAppContext().getString(2131755736) + " " + JoH.dateTimeText(reminder.last_fired);
                }
                str = str4 + " (x" + reminder.fired_times + ") " + xdrip.getAppContext().getString(2131755884);
            } else {
                str = "";
            }
            if (!reminder.enabled) {
                str2 = "";
            } else if (Math.abs(JoH.msSince(reminder.next_due)) < 86400000) {
                str2 = "" + JoH.hourMinuteString(reminder.next_due);
            } else {
                str2 = "" + JoH.dateTimeText(reminder.next_due).substring(0, r1.length() - 3);
            }
            myViewHolder2.small_text.setText(str + " " + str2);
            long max = Math.max(JoH.msTill(reminder.next_due), JoH.msTill(reminder.snoozed_till));
            myViewHolder2.wholeBlock.setBackgroundColor(0);
            if (reminder.enabled) {
                myViewHolder2.wholeBlock.setAlpha(1.0f);
                if (reminder.snoozed_till > JoH.tsl() && reminder.next_due < JoH.tsl()) {
                    str3 = xdrip.getAppContext().getString(2131756388) + " " + JoH.niceTimeTill(reminder.snoozed_till);
                } else if (max >= 0) {
                    String niceTimeScalarNatural = JoH.niceTimeScalarNatural(max);
                    if (niceTimeScalarNatural.matches("^[0-9]+.*")) {
                        niceTimeScalarNatural = xdrip.getAppContext().getString(2131755681) + " " + niceTimeScalarNatural;
                    }
                    str3 = xdrip.getAppContext().getString(2131755488) + " " + niceTimeScalarNatural;
                } else {
                    str3 = xdrip.getAppContext().getString(2131755489) + " " + JoH.hourMinuteString(reminder.next_due);
                    myViewHolder2.wholeBlock.setBackgroundColor(Color.parseColor("#660066"));
                    Reminders.access$308(Reminders.this);
                }
            } else {
                str3 = xdrip.getAppContext().getString(2131755366) + " ";
                myViewHolder2.wholeBlock.setAlpha(0.3f);
            }
            TextView textView = myViewHolder2.next_due_text;
            StringBuilder sb = new StringBuilder();
            sb.append(str3);
            if (reminder.repeating) {
                str5 = ", " + xdrip.getAppContext().getString(2131756193) + " " + JoH.niceTimeScalarRedux(reminder.period);
            }
            sb.append(str5);
            textView.setText(sb.toString());
        }

        @Override
        public boolean onItemMove(int i, int i2) {
            if (!JoH.ratelimit("on item move", 5)) {
                return true;
            }
            Reminders reminders = Reminders.this;
            reminders.showReminderDialog(null, reminders.reminders.get(i), 0);
            return true;
        }

        @Override
        public void onItemDismiss(int i) {
            Reminder reminder = Reminders.this.reminders.get(i);
            Cloner cloner = new Cloner();
            Reminders.this.last_undo = (Reminder) cloner.deepClone(reminder);
            if (SimpleItemTouchHelperCallback.last_swipe_direction == 4) {
                Reminders reminders = Reminders.this;
                long j = reminder.last_snoozed_for;
                if (j <= 0) {
                    j = reminders.default_snooze;
                }
                reminders.snoozeReminder(reminder, j);
                Reminders.this.last_swiped = reminder;
                Reminders.this.reminders.remove(i);
                notifyItemRemoved(i);
                Reminders.cancelAlert();
                Reminders.this.showSnoozeFloater();
                Reminders.this.reinjectDelayed(reminder);
                return;
            }
            Reminders.cancelAlert();
            Reminders.this.last_swiped = reminder;
            if (!Reminders.this.rescheduleOrCancelReminder(reminder)) {
                Reminders.this.reinjectDelayed(reminder);
            }
            Reminders.this.reminders.remove(i);
            notifyItemRemoved(i);
        }
    }

    public void reinjectDelayed(final Reminder reminder) {
        JoH.runOnUiThreadDelayed(new Runnable() {
            @Override
            public final void run() {
                Reminders.this.lambda$reinjectDelayed$0(reminder);
            }
        }, 500L);
    }

    public void snoozeReminder(Reminder reminder, long j) {
        if (reminder == null) {
            return;
        }
        reminder.last_snoozed_for = j;
        if (reminder.isDue()) {
            reminder.snoozed_till = JoH.tsl() + j;
            setFloaterText(reminder.getTitle() + " " + xdrip.getAppContext().getString(2131756388) + " " + JoH.niceTimeScalar(j));
        } else {
            reminder.snoozed_till = reminder.next_due + j;
            setFloaterText(reminder.getTitle() + " " + xdrip.getAppContext().getString(2131756032) + " " + JoH.niceTimeScalar(j));
        }
        reminder.save();
    }

    private void updateFloaterForReschedule(Reminder reminder) {
        setFloaterText(reminder.getTitle() + " " + xdrip.getAppContext().getString(2131755886) + " " + JoH.niceTimeTill(reminder.next_due));
        reinjectDelayed(reminder);
        showSnoozeFloater();
    }

    private void rescheduleNextOld(Reminder reminder) {
        reminder.schedule_next();
        updateFloaterForReschedule(reminder);
    }

    private void rescheduleNextNew(Reminder reminder, long j) {
        reminder.schedule_next(j);
        updateFloaterForReschedule(reminder);
    }

    public boolean rescheduleOrCancelReminder(Reminder reminder) {
        if (reminder.repeating || !reminder.isDue()) {
            if (reminder.isOverdue()) {
                askWhenToReschedule(reminder);
                return false;
            }
            rescheduleNextOld(reminder);
            return true;
        }
        if (reminder.repeating) {
            return true;
        }
        setFloaterText(reminder.getTitle() + " " + xdrip.getAppContext().getString(2131755366));
        reminder.enabled = false;
        reminder.save();
        return true;
    }

    private void askWhenToReschedule(final Reminder reminder) {
        long tsl = JoH.tsl();
        long potentialNextSchedule = reminder.getPotentialNextSchedule();
        final long j = tsl + reminder.period;
        AlertDialog.Builder message = new AlertDialog.Builder(this).setTitle(2131756198).setMessage(String.format("%s:    %s  @  %s\n\nor\n\n%s:   %s  @  %s", getString(2131755954), JoH.niceTimeScalarNatural(-JoH.msSince(potentialNextSchedule)), JoH.hourMinuteString(potentialNextSchedule), getString(2131755883), JoH.niceTimeScalarNatural(-JoH.msSince(j)), JoH.hourMinuteString(j)));
        message.setPositiveButton(getString(2131755954), new DialogInterface.OnClickListener() {
            @Override
            public final void onClick(DialogInterface dialogInterface, int i) {
                Reminders.this.lambda$askWhenToReschedule$1(reminder, dialogInterface, i);
            }
        });
        message.setNegativeButton(getString(2131755883), new DialogInterface.OnClickListener() {
            @Override
            public final void onClick(DialogInterface dialogInterface, int i) {
                Reminders.this.lambda$askWhenToReschedule$2(reminder, j, dialogInterface, i);
            }
        });
        AlertDialog create = message.create();
        try {
            if (create.isShowing()) {
                create.dismiss();
            }
        } catch (Exception unused) {
        }
        create.show();
    }

    public void lambda$askWhenToReschedule$1(Reminder reminder, DialogInterface dialogInterface, int i) {
        rescheduleNextOld(reminder);
    }

    public void lambda$askWhenToReschedule$2(Reminder reminder, long j, DialogInterface dialogInterface, int i) {
        rescheduleNextNew(reminder, j);
    }

    public void newReminder(View view) {
        showReminderDialog(view, null, 0);
    }

    private synchronized void playSelectedSound() {
        String str = this.selectedSound;
        if (str == null) {
            str = JoH.getResourceURI(2131689968);
        }
        JoH.playSoundUri(str);
    }

    public void chooseReminderSound(View view) {
        playSelectedSound();
        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setTitle(2131756258).setOnDismissListener(new DialogInterface.OnDismissListener() {
            @Override
            public final void onDismiss(DialogInterface dialogInterface) {
                JoH.stopSoundUri();
            }
        }).setItems(2130903076, new DialogInterface.OnClickListener() {
            @Override
            public final void onClick(DialogInterface dialogInterface, int i) {
                Reminders.this.lambda$chooseReminderSound$4(dialogInterface, i);
            }
        });
        builder.create().show();
    }

    public void lambda$chooseReminderSound$4(DialogInterface dialogInterface, int i) {
        JoH.stopSoundUri();
        if (i == 0) {
            Intent intent = new Intent("android.intent.action.RINGTONE_PICKER");
            intent.putExtra("android.intent.extra.ringtone.TITLE", xdrip.getAppContext().getString(2131756262));
            intent.putExtra("android.intent.extra.ringtone.SHOW_SILENT", true);
            intent.putExtra("android.intent.extra.ringtone.SHOW_DEFAULT", true);
            intent.putExtra("android.intent.extra.ringtone.TYPE", 7);
            startActivityForResult(intent, 55);
            return;
        }
        if (i == 1) {
            if (checkPermissions()) {
                chooseFile();
            }
        } else {
            JoH.static_toast_long(xdrip.getAppContext().getString(2131756992));
            this.selectedSound = null;
            playSelectedSound();
            PersistentStore.setString("reminders-last-sound", "");
        }
    }

    private void chooseFile() {
        Intent intent = new Intent();
        intent.setType("audio/*");
        intent.setAction("android.intent.action.OPEN_DOCUMENT");
        startActivityForResult(Intent.createChooser(intent, xdrip.getAppContext().getString(2131756257)), 2);
    }

    private boolean checkPermissions() {
        if (ContextCompat.checkSelfPermission(getApplicationContext(), "android.permission.WRITE_EXTERNAL_STORAGE") == 0) {
            return true;
        }
        JoH.show_ok_dialog(this, xdrip.getAppContext().getString(2131755014), xdrip.getAppContext().getString(2131755879), new Runnable() {
            @Override
            public void run() {
                ActivityCompat.requestPermissions(this, new String[]{"android.permission.WRITE_EXTERNAL_STORAGE"}, 139);
            }
        });
        return false;
    }

    @Override
    public void onRequestPermissionsResult(int i, String[] strArr, int[] iArr) {
        super.onRequestPermissionsResult(i, strArr, iArr);
        if (i == 139) {
            if (iArr.length > 0 && iArr[0] == 0) {
                chooseFile();
            } else {
                JoH.static_toast_long(this, xdrip.getAppContext().getString(2131755287));
            }
        }
    }

    @Override
    public void onActivityResult(int i, int i2, Intent intent) {
        if (i2 == -1) {
            if (i == 55) {
                Uri uri = (Uri) intent.getParcelableExtra("android.intent.extra.ringtone.PICKED_URI");
                if (uri != null) {
                    String uri2 = uri.toString();
                    this.selectedSound = uri2;
                    PersistentStore.setString("reminders-last-sound", uri2);
                    return;
                }
                return;
            }
            if (i == 2) {
                Uri data = intent.getData();
                try {
                    getContentResolver().takePersistableUriPermission(data, 1);
                    String uri3 = data.toString();
                    this.selectedSound = uri3;
                    PersistentStore.setString("reminders-last-sound", uri3);
                } catch (Exception e) {
                    JoH.static_toast_long(xdrip.getAppContext().getString(2131756149) + " " + e.getMessage());
                }
            }
        }
    }

    public void snoozeAdjust(android.view.View r7) {
        throw new UnsupportedOperationException("Method not decompiled: com.eveningoutpost.dexdrip.Reminders.snoozeAdjust(android.view.View):void");
    }

    public void reminderUpButton(View view) {
        try {
            EditText editText = this.reminderDaysEdt;
            editText.setText(Integer.toString(Integer.parseInt(editText.getText().toString()) + 1));
        } catch (NumberFormatException unused) {
            JoH.static_toast_short(xdrip.getAppContext().getString(2131755712));
        }
    }

    public void reminderDownButton(View view) {
        try {
            this.reminderDaysEdt.setText(Integer.toString(Integer.parseInt(r2.getText().toString()) - 1));
        } catch (NumberFormatException unused) {
            JoH.static_toast_short(xdrip.getAppContext().getString(2131755712));
        }
        if (this.reminderDaysEdt.getText().toString().equals("0")) {
            this.reminderDaysEdt.setText("1");
        }
    }

    public synchronized void reminderTrashButton(View view) {
        Reminder reminder = this.last_undo;
        if (reminder != null) {
            dismissDoppelgangerItem(reminder);
            JoH.static_toast_long(xdrip.getAppContext().getString(2131756890) + " " + this.last_undo.title);
            this.last_undo.delete();
            this.last_undo = null;
            hideSnoozeFloater();
        }
    }

    public void hideFloater(View view) {
        hideSnoozeFloater();
        hideKeyboard(view);
        reloadList();
    }

    public synchronized void undoFromFloater(View view) {
        Reminder reminder = this.last_undo;
        if (reminder != null) {
            dismissDoppelgangerItem(reminder);
            lambda$reinjectDelayed$0(this.last_undo);
            this.last_undo = null;
            hideSnoozeFloater();
        } else {
            JoH.static_toast_short(xdrip.getAppContext().getString(2131755934));
        }
    }

    private synchronized void dismissItem(Reminder reminder) {
        synchronized (this.reminders) {
            try {
                this.mAdapter.notifyItemRemoved(this.reminders.indexOf(reminder));
                this.reminders.remove(reminder);
            } catch (Exception e) {
                Log.d("Reminders", "Dismiss item: " + e);
            }
        }
    }

    private synchronized void dismissDoppelgangerItem(com.eveningoutpost.dexdrip.models.Reminder r5) {
        throw new UnsupportedOperationException("Method not decompiled: com.eveningoutpost.dexdrip.Reminders.dismissDoppelgangerItem(com.eveningoutpost.dexdrip.models.Reminder):void");
    }

    public synchronized void freshen(Reminder reminder) {
        dismissItem(reminder);
        lambda$reinjectDelayed$0(reminder);
    }

    public synchronized void lambda$reinjectDelayed$0(Reminder reminder) {
        if (reminder == null) {
            return;
        }
        dismissDoppelgangerItem(reminder);
        final int reinjectionPosition = reinjectionPosition(reminder);
        Log.d("Reminders", "child Reinjection position: " + reinjectionPosition);
        this.reminders.add(reinjectionPosition, reminder);
        this.mAdapter.notifyItemInserted(reinjectionPosition);
        final AtomicBoolean atomicBoolean = new AtomicBoolean();
        this.recyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
            @Override
            public void onScrollStateChanged(RecyclerView recyclerView, int i) {
                if (i == 0) {
                    recyclerView.removeOnScrollListener(this);
                    Reminders.this.correctiveScrolling(reinjectionPosition, atomicBoolean);
                }
            }
        });
        if (this.highlighted < 2) {
            Log.d("Reminders", "Reinjection: scrolling to: " + reinjectionPosition);
            this.recyclerView.smoothScrollToPosition(reinjectionPosition);
            JoH.runOnUiThreadDelayed(new Runnable() {
                @Override
                public void run() {
                    Reminders.this.correctiveScrolling(reinjectionPosition, atomicBoolean);
                }
            }, 1000L);
        } else {
            Log.d("Reminders", "Not scrolling due to highlighted: " + this.highlighted);
        }
    }

    public void correctiveScrolling(int i, AtomicBoolean atomicBoolean) {
        float top = this.floatingsnooze.getTop();
        if (atomicBoolean.getAndSet(true)) {
            return;
        }
        int i2 = 0;
        int i3 = 0;
        while (i2 > -1) {
            View childAt = this.recyclerView.getChildAt(i3);
            if (childAt != null) {
                int childAdapterPosition = this.recyclerView.getChildAdapterPosition(childAt);
                if (childAdapterPosition == i) {
                    float y = childAt.getY() + (childAt.getHeight() * 2);
                    if (y > top) {
                        StringBuilder sb = new StringBuilder();
                        sb.append("Corrective Scrolling by: ");
                        int i4 = (int) (y - top);
                        sb.append(i4);
                        Log.d("Reminders", sb.toString());
                        this.recyclerView.smoothScrollBy(0, i4);
                    }
                } else {
                    i2 = childAdapterPosition;
                    i3++;
                }
            }
            i2 = -1;
            i3++;
        }
    }

    private synchronized int reinjectionPosition(Reminder reminder) {
        if (reminder == null) {
            return 0;
        }
        synchronized (this.reminders) {
            int size = this.reminders.size() - 1;
            int i = -1;
            for (int i2 = size; i2 > 0; i2--) {
                if (reminder.next_due < this.reminders.get(i2).next_due && reminder.enabled == this.reminders.get(i2).enabled) {
                    i = i2;
                } else if ((i != -1 || i2 == size) && reminder.next_due >= this.reminders.get(i2).next_due && reminder.enabled == this.reminders.get(i2).enabled) {
                    if (i2 == size) {
                        i = size + 1;
                    }
                    return i;
                }
            }
            if (reminder.enabled) {
                return 0;
            }
            Log.d("Reminders", "Returning reinjection max_count+1 due to non enabled");
            return size + 1;
        }
    }

    public void showReminderDialog(android.view.View r30, final com.eveningoutpost.dexdrip.models.Reminder r31, int r32) {
        throw new UnsupportedOperationException("Method not decompiled: com.eveningoutpost.dexdrip.Reminders.showReminderDialog(android.view.View, com.eveningoutpost.dexdrip.models.Reminder, int):void");
    }

    public long getPeriod(RadioButton radioButton, RadioButton radioButton2, RadioButton radioButton3) {
        long j;
        long j2;
        try {
            j = Integer.parseInt(this.reminderDaysEdt.getText().toString());
        } catch (NumberFormatException unused) {
            j = 1;
            try {
                this.reminderDaysEdt.setText("1");
            } catch (Exception unused2) {
            }
        }
        if (radioButton.isChecked()) {
            j2 = 86400000;
        } else if (radioButton2.isChecked()) {
            j2 = 3600000;
        } else {
            if (!radioButton3.isChecked()) {
                return j;
            }
            j2 = 604800000;
        }
        return j * j2;
    }

    public void maskAlternatingCheckbox(boolean z, CheckBox checkBox) {
        if (z) {
            checkBox.setEnabled(true);
        } else {
            checkBox.setEnabled(false);
            checkBox.setChecked(false);
        }
    }

    private int getPositionFromReminderId(int i) {
        for (int i2 = 0; i2 < this.reminders.size(); i2++) {
            if (this.reminders.get(i2).getId().longValue() == i) {
                return i2;
            }
        }
        return -1;
    }

    public static void doAlert(final Reminder reminder) {
        JoH.getWakeLock("reminder-alert-wakeup", 20000);
        if (JoH.isOngoingCall()) {
            UserError.Log.uel("Reminders", "Not alerting due to ongoing call");
            return;
        }
        Log.d("Reminders", "Scheduling alert reminder in 10 seconds time");
        JoH.runOnUiThreadDelayed(new Runnable() {
            @Override
            public void run() {
                Log.d("Reminders", "delayed wakeup firing");
                Reminders.startReminderWithExtra("REMINDER_WAKEUP", Reminder.this.getId().toString());
            }
        }, 9000L);
        JoH.runOnUiThreadDelayed(new Runnable() {
            @Override
            public void run() {
                Uri parse;
                String str;
                Log.d("Reminders", "delayed alert firing");
                Intent putExtra = new Intent(xdrip.getAppContext(), (Class<?>) Reminders.class).putExtra("reminder_id", Reminder.this.getId().toString());
                PendingIntent broadcast = PendingIntent.getBroadcast(xdrip.getAppContext(), 766, new Intent(xdrip.getAppContext(), (Class<?>) ReminderReceiver.class).setAction("reminder").putExtra("snooze_id", Reminder.this.getId()).putExtra(Pref.getBooleanDefaultFalse(Reminder.REMINDERS_CANCEL_DEFAULT) ? "cancel" : "snooze", "true"), 134217728);
                PendingIntent activity = PendingIntent.getActivity(xdrip.getAppContext(), 765, putExtra, 134217728);
                if (Reminder.this.graphicon) {
                    Treatments.create_note("Reminder: " + Reminder.this.getTitle(), JoH.tsl());
                }
                String title = Reminder.this.getTitle();
                String str2 = xdrip.getAppContext().getString(2131756179) + " " + JoH.hourMinuteString(Reminder.this.next_due);
                if (JoH.isOngoingCall()) {
                    parse = null;
                } else {
                    String str3 = Reminder.this.sound_uri;
                    if (str3 == null) {
                        str3 = JoH.getResourceURI(2131689968);
                    }
                    parse = Uri.parse(str3);
                }
                JoH.showNotification(title, str2, activity, 765, "reminderChannel", true, true, broadcast, parse, null);
                StringBuilder sb = new StringBuilder();
                sb.append(Reminder.this.getTitle());
                sb.append(" due: ");
                sb.append(JoH.dateTimeText(Reminder.this.next_due));
                Reminder reminder2 = Reminder.this;
                if (reminder2.snoozed_till > reminder2.next_due) {
                    str = " snoozed till: " + JoH.dateTimeText(Reminder.this.snoozed_till);
                } else {
                    str = "";
                }
                sb.append(str);
                UserError.Log.ueh("Reminder Alert", sb.toString());
                Reminder reminder3 = Reminder.this;
                if (reminder3.speak) {
                    SpeechUtil.say(reminder3.getTitle(), 1000L, 3);
                }
                Reminder.this.notified();
            }
        }, 10000L);
    }

    public static void cancelAlert() {
        JoH.runOnUiThreadDelayed(new Runnable() {
            @Override
            public void run() {
                Log.d("Reminders", "Cancelling notification");
                JoH.cancelNotification(765);
            }
        }, 500L);
    }

    public void askTime(int i) {
        final Calendar calendar = Calendar.getInstance();
        final Reminder reminder = this.reminders.get(i);
        calendar.setTimeInMillis(reminder.next_due);
        TimePickerFragment timePickerFragment = new TimePickerFragment();
        timePickerFragment.setTime(calendar.get(11), calendar.get(12));
        timePickerFragment.setTitle(xdrip.getAppContext().getString(2131756873));
        timePickerFragment.setTimeCallback(new ProfileAdapter.TimePickerCallbacks() {
            @Override
            public void onTimeUpdated(int i2) {
                int i3 = i2 % 60;
                Calendar calendar2 = calendar;
                calendar2.set(calendar2.get(1), calendar.get(2), calendar.get(5), (i2 - i3) / 60, i3);
                reminder.next_due = calendar.getTimeInMillis();
                Reminder reminder2 = reminder;
                reminder2.snoozed_till = 0L;
                reminder2.save();
                Reminders.this.freshen(reminder);
            }
        });
        timePickerFragment.show(getFragmentManager(), "TimePicker");
        if (JoH.msTill(reminder.next_due) > 86400000) {
            DatePickerFragment datePickerFragment = new DatePickerFragment();
            datePickerFragment.setAllowFuture(true);
            datePickerFragment.setEarliestDate(JoH.tsl());
            datePickerFragment.setInitiallySelectedDate(reminder.next_due);
            datePickerFragment.setTitle(xdrip.getAppContext().getString(2131756874));
            datePickerFragment.setDateCallback(new ProfileAdapter.DatePickerCallbacks() {
                @Override
                public void onDateSet(int i2, int i3, int i4) {
                    calendar.set(i2, i3, i4);
                }
            });
            datePickerFragment.show(getFragmentManager(), "DatePicker");
        }
    }

    private synchronized void hideSnoozeFloater() {
        if (!this.floaterHidden) {
            animateSnoozeFloater(0.0f, this.floatingsnooze.getHeight(), new AccelerateInterpolator(1.5f));
            this.floaterHidden = true;
        }
    }

    public synchronized void showSnoozeFloater() {
        if (this.floaterHidden) {
            animateSnoozeFloater(this.floatingsnooze.getHeight(), 0.0f, new DecelerateInterpolator(1.5f));
            this.floaterHidden = false;
            this.floatingsnooze.setVisibility(0);
            showcase(this, 16);
        }
        hideKeyboard(this.recyclerView);
    }

    private void setFloaterText(String str) {
        Log.d("Reminders", "Setting floater text:" + str);
        try {
            this.floaterText.setText(str);
        } catch (Exception unused) {
            UserError.Log.e("Reminders", "Unable to set floater text to: " + str);
        }
    }

    private void animateSnoozeFloater(float f, float f2, Interpolator interpolator) {
        ValueAnimator ofFloat = ValueAnimator.ofFloat(f, f2);
        ofFloat.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator valueAnimator) {
                Reminders.this.floatingsnooze.setTranslationY(((Float) valueAnimator.getAnimatedValue()).floatValue());
            }
        });
        ofFloat.setInterpolator(interpolator);
        ofFloat.setDuration(500L);
        ofFloat.start();
    }

    public static void startReminderWithExtra(String str, String str2) {
        Intent intent = new Intent(xdrip.getAppContext(), (Class<?>) Reminders.class);
        intent.setFlags(268435456);
        intent.putExtra(str, str2);
        xdrip.getAppContext().startActivity(intent);
    }

    public void processIncomingBundle(Bundle bundle) {
        JoH.getWakeLock("reminder-bundler", ErrorCode.INVALID_OWNERSHIP);
        if (bundle != null) {
            for (String str : bundle.keySet()) {
                Object obj = bundle.get(str);
                if (obj != null) {
                    Log.d("Reminders", String.format("Bundle: %s %s (%s)", str, obj.toString(), obj.getClass().getName()));
                }
            }
            if (bundle.getString("snooze") != null) {
                long j = bundle.getLong("snooze_id");
                Log.d("Reminders", "Reminder id for snooze: " + j);
                Reminder byid = Reminder.byid(j);
                if (byid != null) {
                    UserError.Log.uel("Reminders", "Reminder snooze for " + byid.title);
                    long j2 = byid.last_snoozed_for;
                    if (j2 <= 0) {
                        j2 = this.default_snooze;
                    }
                    snoozeReminder(byid, j2);
                    JoH.static_toast_long(xdrip.getAppContext().getString(2131756389) + " " + JoH.niceTimeScalar(j2));
                    reloadList();
                    hideSnoozeFloater();
                    hideKeyboard(this.recyclerView);
                    return;
                }
                return;
            }
            if (bundle.getString("cancel") != null) {
                Log.d("Reminders", "Cancel/Reschedule reminder from intent");
                long j3 = bundle.getLong("snooze_id");
                Log.d("Reminders", "Reminder id for snooze: " + j3);
                Reminder byid2 = Reminder.byid(j3);
                if (byid2 != null) {
                    UserError.Log.uel("Reminders", "Reminder cancel for " + byid2.title);
                    if (rescheduleOrCancelReminder(byid2)) {
                        reloadList();
                        hideSnoozeFloater();
                        hideKeyboard(this.recyclerView);
                        return;
                    }
                    return;
                }
                return;
            }
            Log.d("Reminders", "Processing non null default bundle");
            reloadList();
            hideSnoozeFloater();
            hideKeyboard(this.recyclerView);
            JoH.runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    Reminders.this.wakeUpScreen(false);
                }
            });
            if (bundle.getString("REMINDER_WAKEUP") != null) {
                try {
                    this.recyclerView.smoothScrollToPosition(getPositionFromReminderId(Integer.parseInt(bundle.getString("REMINDER_WAKEUP"))));
                } catch (IllegalArgumentException unused) {
                    Log.e("Reminders", "Couldn't scroll to position");
                }
                JoH.runOnUiThreadDelayed(new Runnable() {
                    @Override
                    public void run() {
                        Log.d("Reminders", "Checking for sensor: " + Reminders.proximity);
                        if (Reminders.proximity) {
                            return;
                        }
                        Reminders.this.wakeUpScreen(true);
                    }
                }, 2000L);
            }
        }
    }

    private void hideKeyboard(View view) {
        if (view == null) {
            return;
        }
        ((InputMethodManager) getSystemService("input_method")).hideSoftInputFromWindow(view.getWindowToken(), 0);
    }

    public void wakeUpScreen(boolean z) {
        final int i;
        if (!JoH.isScreenOn() || z) {
            Log.d("Reminders", "Wake up screen called with unlock = " + z);
            if (z) {
                i = 2621569;
            } else {
                ((PowerManager) xdrip.getAppContext().getSystemService("power")).newWakeLock(268435482, "reminder-lockscreen").acquire(10000L);
                i = 2097280;
            }
            final PowerManager.WakeLock wakeLock = JoH.getWakeLock("reminder-full-wakeup", 61000);
            final Window window = getWindow();
            window.addFlags(i);
            new Timer().schedule(new TimerTask() {
                @Override
                public void run() {
                    JoH.runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            AnonymousClass21 anonymousClass21 = AnonymousClass21.this;
                            window.clearFlags(i);
                        }
                    });
                    JoH.releaseWakeLock(wakeLock);
                }
            }, 60000L);
            return;
        }
        Log.d("Reminders", "Screen is already on so not turning on");
    }

    public static void showcase(final Activity activity, final int i) {
        ViewTarget viewTarget;
        long j;
        final String string;
        final String string2;
        final ViewTarget viewTarget2;
        ViewTarget viewTarget3;
        final int i2 = 200;
        final int i3 = 70;
        if (ShotStateStore.hasShot(i)) {
        }
        switch (i) {
            case 14:
                viewTarget = new ViewTarget(2131296611, activity);
                j = 200;
                string = xdrip.getAppContext().getString(2131756648);
                string2 = xdrip.getAppContext().getString(2131755816);
                viewTarget2 = viewTarget;
                JoH.runOnUiThreadDelayed(new Runnable() {
                    @Override
                    public void run() {
                        ShowcaseView build;
                        if (ViewTarget.this != null) {
                            build = new ShowcaseView.Builder(activity).setStyle(2131820768).setContentTitle(string).setTarget(ViewTarget.this).blockAllTouches().setContentText("\n" + string2).setShowcaseDrawer(new JamorhamShowcaseDrawer(activity.getResources(), activity.getTheme(), i2, i3, 255)).singleShot(i).build();
                        } else {
                            build = new ShowcaseView.Builder(activity).setStyle(2131820768).setContentTitle(string).blockAllTouches().setContentText("\n" + string2).setShowcaseDrawer(new JamorhamShowcaseDrawer(activity.getResources(), activity.getTheme(), i2, i3, 255)).singleShot(i).build();
                        }
                        build.setTag(Integer.valueOf(i));
                        build.setBackgroundColor(0);
                        build.setShouldCentreText(false);
                        build.setOnShowcaseEventListener(new OnShowcaseEventListener() {
                            @Override
                            public void onShowcaseViewHide(ShowcaseView showcaseView) {
                            }

                            @Override
                            public void onShowcaseViewShow(ShowcaseView showcaseView) {
                            }

                            @Override
                            public void onShowcaseViewTouchBlocked(MotionEvent motionEvent) {
                            }

                            @Override
                            public void onShowcaseViewDidHide(ShowcaseView showcaseView) {
                                int intValue = ((Integer) showcaseView.getTag()).intValue();
                                if (intValue == 16) {
                                    Reminders.showcase(activity, 17);
                                } else if (intValue == 17) {
                                    Reminders.showcase(activity, 19);
                                } else {
                                    if (intValue != 19) {
                                        return;
                                    }
                                    Reminders.showcase(activity, 20);
                                }
                            }
                        });
                        RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(-2, -2);
                        int dimension = (int) activity.getResources().getDimension(R$dimen.button_margin);
                        layoutParams.setMargins(dimension, dimension, dimension, dimension);
                        layoutParams.addRule(9);
                        layoutParams.addRule(12);
                        build.setButtonPosition(layoutParams);
                        build.show();
                    }
                }, j);
                break;
            case 15:
                j = 1000;
                string = xdrip.getAppContext().getString(2131756852);
                string2 = xdrip.getAppContext().getString(2131755821);
                viewTarget2 = null;
                JoH.runOnUiThreadDelayed(new Runnable() {
                    @Override
                    public void run() {
                        ShowcaseView build;
                        if (ViewTarget.this != null) {
                            build = new ShowcaseView.Builder(activity).setStyle(2131820768).setContentTitle(string).setTarget(ViewTarget.this).blockAllTouches().setContentText("\n" + string2).setShowcaseDrawer(new JamorhamShowcaseDrawer(activity.getResources(), activity.getTheme(), i2, i3, 255)).singleShot(i).build();
                        } else {
                            build = new ShowcaseView.Builder(activity).setStyle(2131820768).setContentTitle(string).blockAllTouches().setContentText("\n" + string2).setShowcaseDrawer(new JamorhamShowcaseDrawer(activity.getResources(), activity.getTheme(), i2, i3, 255)).singleShot(i).build();
                        }
                        build.setTag(Integer.valueOf(i));
                        build.setBackgroundColor(0);
                        build.setShouldCentreText(false);
                        build.setOnShowcaseEventListener(new OnShowcaseEventListener() {
                            @Override
                            public void onShowcaseViewHide(ShowcaseView showcaseView) {
                            }

                            @Override
                            public void onShowcaseViewShow(ShowcaseView showcaseView) {
                            }

                            @Override
                            public void onShowcaseViewTouchBlocked(MotionEvent motionEvent) {
                            }

                            @Override
                            public void onShowcaseViewDidHide(ShowcaseView showcaseView) {
                                int intValue = ((Integer) showcaseView.getTag()).intValue();
                                if (intValue == 16) {
                                    Reminders.showcase(activity, 17);
                                } else if (intValue == 17) {
                                    Reminders.showcase(activity, 19);
                                } else {
                                    if (intValue != 19) {
                                        return;
                                    }
                                    Reminders.showcase(activity, 20);
                                }
                            }
                        });
                        RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(-2, -2);
                        int dimension = (int) activity.getResources().getDimension(R$dimen.button_margin);
                        layoutParams.setMargins(dimension, dimension, dimension, dimension);
                        layoutParams.addRule(9);
                        layoutParams.addRule(12);
                        build.setButtonPosition(layoutParams);
                        build.show();
                    }
                }, j);
                break;
            case 16:
                viewTarget = new ViewTarget(2131296668, activity);
                String string3 = xdrip.getAppContext().getString(2131756832);
                string2 = xdrip.getAppContext().getString(2131755817);
                j = 1000;
                string = string3;
                viewTarget2 = viewTarget;
                JoH.runOnUiThreadDelayed(new Runnable() {
                    @Override
                    public void run() {
                        ShowcaseView build;
                        if (ViewTarget.this != null) {
                            build = new ShowcaseView.Builder(activity).setStyle(2131820768).setContentTitle(string).setTarget(ViewTarget.this).blockAllTouches().setContentText("\n" + string2).setShowcaseDrawer(new JamorhamShowcaseDrawer(activity.getResources(), activity.getTheme(), i2, i3, 255)).singleShot(i).build();
                        } else {
                            build = new ShowcaseView.Builder(activity).setStyle(2131820768).setContentTitle(string).blockAllTouches().setContentText("\n" + string2).setShowcaseDrawer(new JamorhamShowcaseDrawer(activity.getResources(), activity.getTheme(), i2, i3, 255)).singleShot(i).build();
                        }
                        build.setTag(Integer.valueOf(i));
                        build.setBackgroundColor(0);
                        build.setShouldCentreText(false);
                        build.setOnShowcaseEventListener(new OnShowcaseEventListener() {
                            @Override
                            public void onShowcaseViewHide(ShowcaseView showcaseView) {
                            }

                            @Override
                            public void onShowcaseViewShow(ShowcaseView showcaseView) {
                            }

                            @Override
                            public void onShowcaseViewTouchBlocked(MotionEvent motionEvent) {
                            }

                            @Override
                            public void onShowcaseViewDidHide(ShowcaseView showcaseView) {
                                int intValue = ((Integer) showcaseView.getTag()).intValue();
                                if (intValue == 16) {
                                    Reminders.showcase(activity, 17);
                                } else if (intValue == 17) {
                                    Reminders.showcase(activity, 19);
                                } else {
                                    if (intValue != 19) {
                                        return;
                                    }
                                    Reminders.showcase(activity, 20);
                                }
                            }
                        });
                        RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(-2, -2);
                        int dimension = (int) activity.getResources().getDimension(R$dimen.button_margin);
                        layoutParams.setMargins(dimension, dimension, dimension, dimension);
                        layoutParams.addRule(9);
                        layoutParams.addRule(12);
                        build.setButtonPosition(layoutParams);
                        build.show();
                    }
                }, j);
                break;
            case 17:
                viewTarget3 = new ViewTarget(2131296894, activity);
                string = xdrip.getAppContext().getString(2131756850);
                string2 = xdrip.getAppContext().getString(2131755820);
                j = 10;
                viewTarget2 = viewTarget3;
                JoH.runOnUiThreadDelayed(new Runnable() {
                    @Override
                    public void run() {
                        ShowcaseView build;
                        if (ViewTarget.this != null) {
                            build = new ShowcaseView.Builder(activity).setStyle(2131820768).setContentTitle(string).setTarget(ViewTarget.this).blockAllTouches().setContentText("\n" + string2).setShowcaseDrawer(new JamorhamShowcaseDrawer(activity.getResources(), activity.getTheme(), i2, i3, 255)).singleShot(i).build();
                        } else {
                            build = new ShowcaseView.Builder(activity).setStyle(2131820768).setContentTitle(string).blockAllTouches().setContentText("\n" + string2).setShowcaseDrawer(new JamorhamShowcaseDrawer(activity.getResources(), activity.getTheme(), i2, i3, 255)).singleShot(i).build();
                        }
                        build.setTag(Integer.valueOf(i));
                        build.setBackgroundColor(0);
                        build.setShouldCentreText(false);
                        build.setOnShowcaseEventListener(new OnShowcaseEventListener() {
                            @Override
                            public void onShowcaseViewHide(ShowcaseView showcaseView) {
                            }

                            @Override
                            public void onShowcaseViewShow(ShowcaseView showcaseView) {
                            }

                            @Override
                            public void onShowcaseViewTouchBlocked(MotionEvent motionEvent) {
                            }

                            @Override
                            public void onShowcaseViewDidHide(ShowcaseView showcaseView) {
                                int intValue = ((Integer) showcaseView.getTag()).intValue();
                                if (intValue == 16) {
                                    Reminders.showcase(activity, 17);
                                } else if (intValue == 17) {
                                    Reminders.showcase(activity, 19);
                                } else {
                                    if (intValue != 19) {
                                        return;
                                    }
                                    Reminders.showcase(activity, 20);
                                }
                            }
                        });
                        RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(-2, -2);
                        int dimension = (int) activity.getResources().getDimension(R$dimen.button_margin);
                        layoutParams.setMargins(dimension, dimension, dimension, dimension);
                        layoutParams.addRule(9);
                        layoutParams.addRule(12);
                        build.setButtonPosition(layoutParams);
                        build.show();
                    }
                }, j);
                break;
            case 19:
                viewTarget3 = new ViewTarget(2131296670, activity);
                string = xdrip.getAppContext().getString(2131756848);
                string2 = xdrip.getAppContext().getString(2131755818);
                j = 10;
                viewTarget2 = viewTarget3;
                JoH.runOnUiThreadDelayed(new Runnable() {
                    @Override
                    public void run() {
                        ShowcaseView build;
                        if (ViewTarget.this != null) {
                            build = new ShowcaseView.Builder(activity).setStyle(2131820768).setContentTitle(string).setTarget(ViewTarget.this).blockAllTouches().setContentText("\n" + string2).setShowcaseDrawer(new JamorhamShowcaseDrawer(activity.getResources(), activity.getTheme(), i2, i3, 255)).singleShot(i).build();
                        } else {
                            build = new ShowcaseView.Builder(activity).setStyle(2131820768).setContentTitle(string).blockAllTouches().setContentText("\n" + string2).setShowcaseDrawer(new JamorhamShowcaseDrawer(activity.getResources(), activity.getTheme(), i2, i3, 255)).singleShot(i).build();
                        }
                        build.setTag(Integer.valueOf(i));
                        build.setBackgroundColor(0);
                        build.setShouldCentreText(false);
                        build.setOnShowcaseEventListener(new OnShowcaseEventListener() {
                            @Override
                            public void onShowcaseViewHide(ShowcaseView showcaseView) {
                            }

                            @Override
                            public void onShowcaseViewShow(ShowcaseView showcaseView) {
                            }

                            @Override
                            public void onShowcaseViewTouchBlocked(MotionEvent motionEvent) {
                            }

                            @Override
                            public void onShowcaseViewDidHide(ShowcaseView showcaseView) {
                                int intValue = ((Integer) showcaseView.getTag()).intValue();
                                if (intValue == 16) {
                                    Reminders.showcase(activity, 17);
                                } else if (intValue == 17) {
                                    Reminders.showcase(activity, 19);
                                } else {
                                    if (intValue != 19) {
                                        return;
                                    }
                                    Reminders.showcase(activity, 20);
                                }
                            }
                        });
                        RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(-2, -2);
                        int dimension = (int) activity.getResources().getDimension(R$dimen.button_margin);
                        layoutParams.setMargins(dimension, dimension, dimension, dimension);
                        layoutParams.addRule(9);
                        layoutParams.addRule(12);
                        build.setButtonPosition(layoutParams);
                        build.show();
                    }
                }, j);
                break;
            case 20:
                viewTarget3 = new ViewTarget(2131296448, activity);
                string = xdrip.getAppContext().getString(2131756849);
                string2 = xdrip.getAppContext().getString(2131755819);
                j = 10;
                viewTarget2 = viewTarget3;
                JoH.runOnUiThreadDelayed(new Runnable() {
                    @Override
                    public void run() {
                        ShowcaseView build;
                        if (ViewTarget.this != null) {
                            build = new ShowcaseView.Builder(activity).setStyle(2131820768).setContentTitle(string).setTarget(ViewTarget.this).blockAllTouches().setContentText("\n" + string2).setShowcaseDrawer(new JamorhamShowcaseDrawer(activity.getResources(), activity.getTheme(), i2, i3, 255)).singleShot(i).build();
                        } else {
                            build = new ShowcaseView.Builder(activity).setStyle(2131820768).setContentTitle(string).blockAllTouches().setContentText("\n" + string2).setShowcaseDrawer(new JamorhamShowcaseDrawer(activity.getResources(), activity.getTheme(), i2, i3, 255)).singleShot(i).build();
                        }
                        build.setTag(Integer.valueOf(i));
                        build.setBackgroundColor(0);
                        build.setShouldCentreText(false);
                        build.setOnShowcaseEventListener(new OnShowcaseEventListener() {
                            @Override
                            public void onShowcaseViewHide(ShowcaseView showcaseView) {
                            }

                            @Override
                            public void onShowcaseViewShow(ShowcaseView showcaseView) {
                            }

                            @Override
                            public void onShowcaseViewTouchBlocked(MotionEvent motionEvent) {
                            }

                            @Override
                            public void onShowcaseViewDidHide(ShowcaseView showcaseView) {
                                int intValue = ((Integer) showcaseView.getTag()).intValue();
                                if (intValue == 16) {
                                    Reminders.showcase(activity, 17);
                                } else if (intValue == 17) {
                                    Reminders.showcase(activity, 19);
                                } else {
                                    if (intValue != 19) {
                                        return;
                                    }
                                    Reminders.showcase(activity, 20);
                                }
                            }
                        });
                        RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(-2, -2);
                        int dimension = (int) activity.getResources().getDimension(R$dimen.button_margin);
                        layoutParams.setMargins(dimension, dimension, dimension, dimension);
                        layoutParams.addRule(9);
                        layoutParams.addRule(12);
                        build.setButtonPosition(layoutParams);
                        build.show();
                    }
                }, j);
                break;
        }
    }
}