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

package com.eveningoutpost.dexdrip;

import android.content.Intent;
import android.graphics.Color;
import android.os.Bundle;
import android.util.SparseBooleanArray;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.MotionEvent;
import android.view.ScaleGestureDetector;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.Animation;
import android.view.animation.AnimationUtils;
import android.widget.CompoundButton;
import android.widget.TextView;
import androidx.appcompat.widget.SearchView;
import androidx.core.view.MenuItemCompat;
import androidx.databinding.ObservableArrayList;
import androidx.databinding.ObservableBoolean;
import androidx.databinding.ObservableList;
import androidx.databinding.ViewDataBinding;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import com.eveningoutpost.dexdrip.EventLogActivity;
import com.eveningoutpost.dexdrip.databinding.ActivityEventLogBinding;
import com.eveningoutpost.dexdrip.models.JoH;
import com.eveningoutpost.dexdrip.models.UserError;
import com.eveningoutpost.dexdrip.ui.helpers.BitmapUtil;
import com.eveningoutpost.dexdrip.utilitymodels.Inevitable;
import com.eveningoutpost.dexdrip.utilitymodels.PersistentStore;
import com.eveningoutpost.dexdrip.utilitymodels.Pref;
import com.eveningoutpost.dexdrip.utilitymodels.SaveLogs;
import com.eveningoutpost.dexdrip.utilitymodels.SendFeedBack;
import com.eveningoutpost.dexdrip.utils.DexCollectionType;
import com.eveningoutpost.dexdrip.utils.ExtensionMethods;
import com.eveningoutpost.dexdrip.wearintegration.WatchUpdaterService;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import me.tatarka.bindingcollectionadapter2.BindingRecyclerViewAdapter;
import me.tatarka.bindingcollectionadapter2.ItemBinding;
import me.tatarka.bindingcollectionadapter2.collections.MergeObservableList;

public class EventLogActivity extends BaseAppCompatActivity {
    private static int MAX_LOG_PACKAGE_SIZE;
    private static final String TAG;
    private static final List<Integer> severitiesList;
    private Animation pulseAnimation;
    private RecyclerView recyclerView;
    private ScaleGestureDetector scaleGestureDetector;
    private MenuItem searchItem;
    private SearchView searchView;
    private final ViewModel model = new ViewModel();
    private volatile boolean runRefresh = false;
    private volatile long highest_id = 0;
    private volatile int lastScrollPosition = 0;
    private volatile boolean loading = false;

    static {
        ArrayList arrayList = new ArrayList();
        severitiesList = arrayList;
        TAG = EventLogActivity.class.getSimpleName();
        MAX_LOG_PACKAGE_SIZE = 200000;
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        arrayList.add(5);
        arrayList.add(6);
    }

    @Override
    protected void onCreate(Bundle bundle) {
        this.pulseAnimation = AnimationUtils.loadAnimation(this, 2130772000);
        super.onCreate(bundle);
        ActivityEventLogBinding inflate = ActivityEventLogBinding.inflate(getLayoutInflater());
        inflate.setViewModel(this.model);
        setContentView(inflate.getRoot());
        JoH.fixActionBar(this);
        this.scaleGestureDetector = new ScaleGestureDetector(this, new SimpleOnScaleGestureListener(this.model));
        refreshData();
        getOlderData();
    }

    private boolean shouldStreamWearLogs() {
        return Pref.getBooleanDefaultFalse("wear_sync") && Pref.getBooleanDefaultFalse("sync_wear_logs");
    }

    private void getWearData() {
        Home.startWatchUpdaterService(this, WatchUpdaterService.ACTION_SYNC_LOGS, TAG);
    }

    private void getOlderData() {
        if (this.model.initial_items.size() == 0) {
            UserError.Log.d(TAG, "No initial items loaded yet to find index from");
            return;
        }
        ObservableList<UserError> observableList = this.model.initial_items;
        final long longValue = observableList.get(observableList.size() - 1).getId().longValue();
        Thread thread = new Thread(new Runnable() {
            @Override
            public final void run() {
                EventLogActivity.this.lambda$getOlderData$1(longValue);
            }
        });
        thread.setPriority(1);
        thread.start();
    }

    public void lambda$getOlderData$1(long j) {
        JoH.threadSleep(300L);
        Inevitable.task("show-events-loading-if-slow", 1000L, new Runnable() {
            @Override
            public final void run() {
                EventLogActivity.this.lambda$getOlderData$0();
            }
        });
        this.loading = true;
        this.model.older_items.addAll(UserError.olderThanID(j, 100000));
        this.model.refresh();
        this.loading = false;
        this.model.showLoading.set(false);
    }

    public void lambda$getOlderData$0() {
        if (!this.loading || this.model.isDefaultFilters()) {
            return;
        }
        this.model.showLoading.set(this.loading);
    }

    @Override
    protected void onResume() {
        super.onResume();
        startRefresh();
        updateToTopButtonVisibility(true);
    }

    @Override
    protected void onPause() {
        super.onPause();
        stopRefresh();
    }

    private synchronized void startRefresh() {
        this.runRefresh = true;
        new Thread(new Runnable() {
            @Override
            public final void run() {
                EventLogActivity.this.lambda$startRefresh$2();
            }
        }).start();
    }

    public void lambda$startRefresh$2() {
        boolean shouldStreamWearLogs = shouldStreamWearLogs();
        int i = 0;
        while (this.runRefresh) {
            if (refreshData()) {
                i = 60;
            }
            if (i > 0) {
                JoH.threadSleep(100L);
                i--;
            } else {
                if (shouldStreamWearLogs && JoH.quietratelimit("stream-wear-logs", 2)) {
                    getWearData();
                }
                for (int i2 = 0; i2 < 2 && this.runRefresh; i2++) {
                    JoH.threadSleep(500L);
                }
            }
        }
    }

    private void stopRefresh() {
        this.runRefresh = false;
    }

    private boolean refreshData() {
        List<UserError> newerThanID = UserError.newerThanID(this.highest_id, 500);
        if (newerThanID == null || newerThanID.size() <= 0) {
            return false;
        }
        long longValue = newerThanID.get(0).getId().longValue();
        UserError.Log.d(TAG, "New streamed data size: " + newerThanID.size() + " Highest: " + longValue);
        if (this.highest_id == 0) {
            this.model.newData(newerThanID);
        } else {
            this.model.appendData(newerThanID);
        }
        this.highest_id = longValue;
        return true;
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(2131558405, menu);
        MenuItem findItem = menu.findItem(2131296603);
        this.searchItem = findItem;
        this.searchView = (SearchView) MenuItemCompat.getActionView(findItem);
        if (this.model.getCurrentFilter().length() > 0) {
            pushSearch(this.model.getCurrentFilter(), false);
        }
        this.searchView.setOnQueryTextListener(new SearchView.OnQueryTextListener() {
            @Override
            public boolean onQueryTextSubmit(String str) {
                EventLogActivity.this.model.filterChanged(str);
                return false;
            }

            @Override
            public boolean onQueryTextChange(String str) {
                EventLogActivity.this.model.filterChanged(str);
                return false;
            }
        });
        return true;
    }

    public void returnHome(MenuItem menuItem) {
        startActivity(new Intent(this, (Class<?>) Home.class).setFlags(268435456));
    }

    public void pushSearch(String str, boolean z) {
        MenuItem menuItem = this.searchItem;
        if (menuItem != null && this.searchView != null) {
            menuItem.expandActionView();
            this.searchView.setQuery(str, z);
            this.searchView.clearFocus();
            return;
        }
        UserError.Log.e(TAG, "SearchView is null!");
    }

    public boolean isAtTop() {
        RecyclerView recyclerView = this.recyclerView;
        return recyclerView == null || ((LinearLayoutManager) recyclerView.getLayoutManager()).findFirstVisibleItemPosition() <= 1;
    }

    public void updateToTopButtonVisibility(boolean z) {
        boolean z2 = !isAtTop();
        if (z || z2 != this.model.showScrollToTop.get()) {
            this.model.showScrollToTop.set(z2);
        }
    }

    public synchronized void uploadEventLogs(View view) {
        startActivity(new Intent(getApplicationContext(), (Class<?>) SendFeedBack.class).putExtra("generic_text", packLogs()));
    }

    public synchronized void saveEventLog(View view) {
        startActivity(new Intent(getApplicationContext(), (Class<?>) SaveLogs.class).putExtra("generic_text", packLogs()));
    }

    private String packLogs() {
        StringBuilder sb = new StringBuilder(50000);
        StringBuilder sb2 = new StringBuilder();
        sb2.append("\n");
        sb2.append(this.model.allSeveritiesEnabled() ? "ALL" : this.model.whichSeveritiesEnabled());
        String str = "";
        if (this.model.getCurrentFilter() != "") {
            str = " Search: " + this.model.getCurrentFilter();
        }
        sb2.append(str);
        sb2.append("\n\n");
        sb.append(sb2.toString());
        Iterator<UserError> it = this.model.visible.iterator();
        while (true) {
            if (!it.hasNext()) {
                break;
            }
            sb.append(it.next().toString());
            sb.append("\n");
            if (sb.length() > MAX_LOG_PACKAGE_SIZE) {
                JoH.static_toast_long(this, "Could not package up all logs, using most recent");
                sb.append("\n\nOnly the most recent logs have been included to limit the file size.\n");
                break;
            }
        }
        sb.insert(0, JoH.getDeviceDetails() + "\n" + JoH.getVersionDetails() + "\n" + DexCollectionType.getBestCollectorHardwareName() + "\n===\n\nLog data:\n");
        StringBuilder sb3 = new StringBuilder();
        sb3.append("\n\nCaptured: ");
        sb3.append(JoH.dateTimeText(JoH.tsl()));
        sb.append(sb3.toString());
        return sb.toString();
    }

    public class ViewModel implements View.OnTouchListener {
        public final EventLogViewAdapterChain adapterChain;
        private String currentFilter;
        public final ObservableList<UserError> initial_items;
        public final ItemBinding<UserError> itemBinding;
        public final MergeObservableList<UserError> items;
        private String last_click_filter;
        public View last_clicked_view;
        public final ObservableList<UserError> older_items;
        private final SparseBooleanArray severities;
        public final ObservableBoolean showLoading;
        public final ObservableBoolean showScrollToTop;
        public final ObservableList<UserError> streamed_items;
        public final ObservableList<UserError> visible;

        public ViewModel() {
            ObservableArrayList observableArrayList = new ObservableArrayList();
            this.initial_items = observableArrayList;
            ObservableArrayList observableArrayList2 = new ObservableArrayList();
            this.older_items = observableArrayList2;
            ObservableArrayList observableArrayList3 = new ObservableArrayList();
            this.streamed_items = observableArrayList3;
            this.items = new MergeObservableList().insertList(observableArrayList3).insertList(observableArrayList).insertList(observableArrayList2);
            this.visible = new ObservableArrayList();
            this.itemBinding = ItemBinding.of(5, 2131492988).bindExtra(20, this);
            this.adapterChain = EventLogActivity.this.new EventLogViewAdapterChain();
            this.showScrollToTop = new ObservableBoolean(false);
            this.showLoading = new ObservableBoolean(false);
            this.severities = new SparseBooleanArray();
            this.last_clicked_view = null;
            this.last_click_filter = "";
            this.currentFilter = null;
            Iterator it = EventLogActivity.severitiesList.iterator();
            while (it.hasNext()) {
                int intValue = ((Integer) it.next()).intValue();
                this.severities.put(intValue, PersistentStore.getBoolean("event-log-severity-enabled-" + intValue, true));
            }
        }

        void newData(List<UserError> list) {
            this.initial_items.clear();
            this.initial_items.addAll(list);
            refresh();
        }

        class AnonymousClass1 implements Runnable {
            final List val$newItems;

            AnonymousClass1(List list) {
                this.val$newItems = list;
            }

            @Override
            public void run() {
                synchronized (ViewModel.this.items) {
                    ViewModel.this.streamed_items.addAll(0, this.val$newItems);
                }
                ViewModel.this.refreshNewItems(this.val$newItems.size());
                if (EventLogActivity.this.isAtTop()) {
                    JoH.runOnUiThreadDelayed(new Runnable() {
                        @Override
                        public final void run() {
                            EventLogActivity.ViewModel.AnonymousClass1.this.lambda$run$0();
                        }
                    }, 300L);
                }
            }

            public void lambda$run$0() {
                ViewModel.this.scrollToTop(true);
            }
        }

        void appendData(List<UserError> list) {
            JoH.runOnUiThread(new AnonymousClass1(list));
        }

        public String getCurrentFilter() {
            if (this.currentFilter == null) {
                this.currentFilter = PersistentStore.getString("event-log-last-search-");
            }
            return this.currentFilter;
        }

        public void lambda$refresh$0() {
            filter(getCurrentFilter());
        }

        void refresh() {
            JoH.runOnUiThread(new Runnable() {
                @Override
                public final void run() {
                    EventLogActivity.ViewModel.this.lambda$refresh$0();
                }
            });
        }

        public void lambda$refreshNewItems$1(int i) {
            insertFilteredNewItems(getCurrentFilter(), i);
        }

        void refreshNewItems(final int i) {
            if (i > 0) {
                JoH.runOnUiThread(new Runnable() {
                    @Override
                    public final void run() {
                        EventLogActivity.ViewModel.this.lambda$refreshNewItems$1(i);
                    }
                });
            }
        }

        void filterChanged(String str) {
            this.currentFilter = str.toLowerCase().trim();
            Inevitable.task("event-log-filter-update", 200L, new Runnable() {
                @Override
                public final void run() {
                    EventLogActivity.ViewModel.this.lambda$filterChanged$2();
                }
            });
        }

        public void lambda$filterChanged$2() {
            refresh();
            PersistentStore.setString("event-log-last-search-", this.currentFilter);
        }

        boolean allSeveritiesEnabled() {
            Iterator it = EventLogActivity.severitiesList.iterator();
            while (it.hasNext()) {
                if (!severity(((Integer) it.next()).intValue())) {
                    return false;
                }
            }
            return true;
        }

        String whichSeveritiesEnabled() {
            Iterator it = EventLogActivity.severitiesList.iterator();
            String str = "";
            while (it.hasNext()) {
                int intValue = ((Integer) it.next()).intValue();
                if (severity(intValue)) {
                    str = str + intValue + " ";
                }
            }
            return str;
        }

        void filter(String str) {
            this.currentFilter = ((String) ExtensionMethods.or(str, getCurrentFilter())).toLowerCase().trim();
            this.visible.clear();
            synchronized (this.items) {
                if (isDefaultFilters()) {
                    this.visible.addAll(this.items);
                } else {
                    Iterator it = this.items.iterator();
                    while (it.hasNext()) {
                        UserError userError = (UserError) it.next();
                        if (filterMatch(userError)) {
                            this.visible.add(userError);
                        }
                    }
                }
            }
            this.adapterChain.notifyDataSetChanged();
        }

        private void insertFilteredNewItems(String str, int i) {
            int i2;
            this.currentFilter = ((String) ExtensionMethods.or(str, getCurrentFilter())).toLowerCase().trim();
            synchronized (this.items) {
                Iterator it = this.items.iterator();
                i2 = 0;
                int i3 = 0;
                while (it.hasNext()) {
                    UserError userError = (UserError) it.next();
                    if (filterMatch(userError)) {
                        this.visible.add(0, userError);
                        i2++;
                    }
                    i3++;
                    if (i3 >= i) {
                        break;
                    }
                }
            }
            this.adapterChain.notifyItemRangeChanged(0, i2);
            if (this.visible.size() > 1) {
                this.adapterChain.notifyItemChanged(i2);
            }
        }

        public boolean isDefaultFilters() {
            return ((String) ExtensionMethods.or(this.currentFilter, "")).length() == 0 && allSeveritiesEnabled();
        }

        public boolean filterMatch(UserError userError) {
            return this.severities.get(userError.severity) && (ExtensionMethods.containsIgnoreCaseF(userError.shortError, this.currentFilter) || ExtensionMethods.containsIgnoreCaseF(userError.message, this.currentFilter));
        }

        public boolean showThisTitle(UserError userError) {
            return !this.visible.get(this.visible.indexOf(userError) - 1).shortError.equals(userError.shortError);
        }

        public void scrollToTop() {
            scrollToTop(false);
        }

        public void scrollToTop(boolean z) {
            this.showScrollToTop.set(false);
            if (EventLogActivity.this.recyclerView != null) {
                if (z) {
                    EventLogActivity.this.recyclerView.smoothScrollToPosition(0);
                } else {
                    EventLogActivity.this.recyclerView.scrollToPosition(0);
                }
            }
        }

        public void lastClicked(View view) {
            this.last_clicked_view = view;
            view.startAnimation(EventLogActivity.this.pulseAnimation);
        }

        public void initRecycler(View view) {
            if (view instanceof RecyclerView) {
                EventLogActivity.this.recyclerView = (RecyclerView) view;
            }
            addScaleDetector(view);
        }

        public void addScaleDetector(View view) {
            view.setOnTouchListener(this);
        }

        public boolean titleButtonLongClick(View view) {
            final String charSequence = ((TextView) view).getText().toString();
            if (this.last_click_filter.equals(charSequence)) {
                charSequence = "";
            }
            this.last_click_filter = charSequence;
            JoH.runOnUiThreadDelayed(new Runnable() {
                @Override
                public final void run() {
                    EventLogActivity.ViewModel.this.lambda$titleButtonLongClick$3(charSequence);
                }
            }, 100L);
            return false;
        }

        public void lambda$titleButtonLongClick$3(String str) {
            EventLogActivity.this.pushSearch(str, true);
        }

        public int titleColorForSeverity(int i) {
            if (i != 1) {
                return -1;
            }
            return Color.parseColor("#FFB3E5FC");
        }

        public int colorForSeverity(int i) {
            if (i == 2) {
                return -12303292;
            }
            if (i == 3) {
                return -65536;
            }
            if (i == 4) {
                return -12303292;
            }
            if (i == 5) {
                return Color.parseColor("#ff337777");
            }
            if (i != 6) {
                return 0;
            }
            return Color.parseColor("#ff337733");
        }

        public int colorForPosition(int i) {
            if (i % 2 == 0) {
                return -1;
            }
            return Color.parseColor("#ffffffdd");
        }

        public float textSize(String str) {
            return BitmapUtil.getScreenDensity() * 2.0f * (str.length() > 100 ? 5.0f : 7.0f);
        }

        public boolean severity(int i) {
            return this.severities.get(i);
        }

        public void setSeverity(CompoundButton compoundButton, boolean z, int i) {
            this.severities.put(i, z);
            refresh();
            PersistentStore.setBoolean("event-log-severity-enabled-" + i, z);
        }

        @Override
        public boolean onTouch(View view, MotionEvent motionEvent) {
            EventLogActivity.this.scaleGestureDetector.onTouchEvent(motionEvent);
            return false;
        }
    }

    public class SimpleOnScaleGestureListener extends ScaleGestureDetector.SimpleOnScaleGestureListener {
        private final ViewModel viewModel;

        public SimpleOnScaleGestureListener(ViewModel viewModel) {
            this.viewModel = viewModel;
        }

        @Override
        public boolean onScale(ScaleGestureDetector scaleGestureDetector) {
            float scaleFactor = scaleGestureDetector.getScaleFactor();
            View view = this.viewModel.last_clicked_view;
            if (view == null) {
                return true;
            }
            ((TextView) view).setTextSize(0, ((TextView) view).getTextSize() * scaleFactor);
            return true;
        }
    }

    public class EventLogViewAdapterChain<T> extends BindingRecyclerViewAdapter<T> {
        public EventLogViewAdapterChain() {
        }

        public ViewDataBinding onCreateBinding(LayoutInflater layoutInflater, int i, ViewGroup viewGroup) {
            return super.onCreateBinding(layoutInflater, i, viewGroup);
        }

        public void onBindBinding(ViewDataBinding viewDataBinding, int i, int i2, int i3, T t) {
            super.onBindBinding(viewDataBinding, i, i2, i3, t);
            EventLogActivity.this.lastScrollPosition = i3;
            EventLogActivity.this.updateToTopButtonVisibility(false);
            TextView textView = (TextView) viewDataBinding.getRoot().findViewById(2131296597);
            if (textView != null) {
                textView.setTextColor(EventLogActivity.this.model.colorForPosition(i3));
            }
        }
    }
}