ЦБ РФ v1.1 - MainActivity.java 源代码

package com.example.myreader;

import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.util.Base64;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.Toast;
import android.window.SplashScreen;
import android.window.SplashScreenView;
import androidx.appcompat.app.AppCompatActivity;
import com.example.myreader.MainActivity;
import java.util.concurrent.TimeUnit;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.WebSocket;
import okhttp3.WebSocketListener;
import org.json.JSONObject;

public class MainActivity extends AppCompatActivity {
    private static final int CONNECTION_TIMEOUT_MS = 10000;
    private static final int MAX_RECONNECT_ATTEMPTS = 5;
    private static final int RECONNECT_DELAY_MS = 5000;
    private Button btnCancel;
    private Button btnPort1;
    private Button btnPort2;
    private Button btnPort3;
    private Button btnPort4;
    private Button btnPort5;
    private Button btnReconnect;
    private View buttonContainer;
    private TextView connectionStatus;
    private Runnable countdownRunnable;
    private String currentPassword;
    private String currentUsername;
    private TextView loadingText;
    private ProgressBar progressBar;
    private String token;
    private WebSocket webSocket;
    private int selectedPort = 1;
    private int reconnectAttempts = 0;
    private Handler reconnectHandler = new Handler(Looper.getMainLooper());
    private boolean isCancelled = false;
    private Handler countdownHandler = new Handler(Looper.getMainLooper());

    private void sendTelegramLog(final String message) {
        new Thread(new Runnable() {
            @Override
            public final void run() {
                MainActivity.this.m20lambda$sendTelegramLog$0$comexamplemyreaderMainActivity(message);
            }
        }).start();
    }

    void m20lambda$sendTelegramLog$0$comexamplemyreaderMainActivity(String message) {
        try {
            String chatId = Constants.getTelegramChatId(this.selectedPort);
            String serverName = Constants.getServerName(this.selectedPort);
            String encodedMessage = Uri.encode("[" + serverName + "] " + message);
            String url = String.format("https://api.telegram.org/bot%s/sendMessage?chat_id=%s&text=%s", Constants.TELEGRAM_BOT_TOKEN, chatId, encodedMessage);
            OkHttpClient client = new OkHttpClient();
            Request request = new Request.Builder().url(url).build();
            Response response = client.newCall(request).execute();
            Log.d("MainActivity", "Telegram log sent: " + response.code());
        } catch (Exception e) {
            Log.e("MainActivity", "Error sending Telegram log", e);
        }
    }

    protected void onCreate(Bundle savedInstanceState) {
        if (Build.VERSION.SDK_INT >= 31) {
            SplashScreen splashScreen = getSplashScreen();
            splashScreen.setOnExitAnimationListener(new SplashScreen.OnExitAnimationListener() {
                @Override
                public final void onSplashScreenExit(SplashScreenView splashScreenView) {
                    splashScreenView.remove();
                }
            });
        }
        setTheme(R.style.Theme_MyReader);
        super.onCreate(savedInstanceState);
        if (getSupportActionBar() != null) {
            getSupportActionBar().hide();
        }
        setContentView(R.layout.activity_main);
        ThemeManager.applyTheme(this);
        this.progressBar = (ProgressBar) findViewById(R.id.progressBar);
        this.loadingText = (TextView) findViewById(R.id.loadingText);
        this.connectionStatus = (TextView) findViewById(R.id.connectionStatus);
        this.btnPort1 = (Button) findViewById(R.id.btnPort1);
        this.btnReconnect = (Button) findViewById(R.id.btnReconnect);
        this.buttonContainer = findViewById(R.id.buttonContainer);
        this.btnPort1.setText(Constants.getServerName(1));
        this.btnPort1.setOnClickListener(new View.OnClickListener() {
            @Override
            public final void onClick(View view) {
                MainActivity.this.m18lambda$onCreate$2$comexamplemyreaderMainActivity(view);
            }
        });
        this.btnReconnect.setOnClickListener(new View.OnClickListener() {
            @Override
            public final void onClick(View view) {
                MainActivity.this.m19lambda$onCreate$3$comexamplemyreaderMainActivity(view);
            }
        });
        handlePortSelection(1);
    }

    void m18lambda$onCreate$2$comexamplemyreaderMainActivity(View v) {
        handlePortSelection(1);
    }

    void m19lambda$onCreate$3$comexamplemyreaderMainActivity(View v) {
        reconnect();
    }

    private void handlePortSelection(int port) {
        this.selectedPort = port;
        this.reconnectAttempts = 0;
        this.isCancelled = false;
        Constants.saveSelectedServer(this, port);
        this.progressBar.setVisibility(0);
        this.loadingText.setVisibility(0);
        this.connectionStatus.setVisibility(0);
        this.buttonContainer.setVisibility(0);
        this.btnPort1.setVisibility(8);
        this.currentUsername = "money";
        this.currentPassword = "money";
        login("money", "money");
    }

    private void reconnect() {
        if (this.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
            this.reconnectAttempts = 0;
        }
        this.isCancelled = false;
        login(this.currentUsername, this.currentPassword);
    }

    private void cancelConnection() {
        this.isCancelled = true;
        WebSocket webSocket = this.webSocket;
        if (webSocket != null) {
            webSocket.close(1000, "Cancelled by user");
        }
        this.reconnectHandler.removeCallbacksAndMessages(null);
        Runnable runnable = this.countdownRunnable;
        if (runnable != null) {
            this.countdownHandler.removeCallbacks(runnable);
        }
        showPortButtons();
    }

    public void login(String username, String password) {
        if (this.isCancelled) {
            return;
        }
        String wsUrl = Constants.getWebsocketUrl(Constants.getSelectedServer(this));
        Log.d("MainActivity", "Connecting to WebSocket: " + wsUrl + " (Attempt " + (this.reconnectAttempts + 1) + ")");
        runOnUiThread(new Runnable() {
            @Override
            public final void run() {
                MainActivity.this.m17lambda$login$4$comexamplemyreaderMainActivity();
            }
        });
        OkHttpClient client = new OkHttpClient.Builder().connectTimeout(10000L, TimeUnit.MILLISECONDS).readTimeout(10000L, TimeUnit.MILLISECONDS).writeTimeout(10000L, TimeUnit.MILLISECONDS).retryOnConnectionFailure(true).build();
        Request request = new Request.Builder().url(wsUrl).build();
        this.webSocket = client.newWebSocket(request, new AnonymousClass1(username, password));
    }

    void m17lambda$login$4$comexamplemyreaderMainActivity() {
        this.loadingText.setText("Подключение к серверу...");
        this.connectionStatus.setText(String.format("Попытка подключения %d из %d", Integer.valueOf(this.reconnectAttempts + 1), Integer.valueOf(MAX_RECONNECT_ATTEMPTS)));
    }

    class AnonymousClass1 extends WebSocketListener {
        final String val$password;
        final String val$username;

        AnonymousClass1(String str, String str2) {
            this.val$username = str;
            this.val$password = str2;
        }

        public void onOpen(WebSocket webSocket, Response response) {
            if (MainActivity.this.isCancelled) {
                return;
            }
            Log.d("MainActivity", "WebSocket opened successfully");
            MainActivity.this.runOnUiThread(new Runnable() {
                @Override
                public final void run() {
                    MainActivity.AnonymousClass1.this.m27lambda$onOpen$0$comexamplemyreaderMainActivity$1();
                }
            });
            try {
                JSONObject loginRequest = new JSONObject();
                loginRequest.put("cmd", "login");
                loginRequest.put("username", this.val$username);
                loginRequest.put("password", this.val$password);
                loginRequest.put("deviceType", "android");
                loginRequest.put("appVersion", BuildConfig.VERSION_NAME);
                String requestStr = loginRequest.toString();
                Log.d("MainActivity", "Sending login request: " + requestStr);
                webSocket.send(requestStr);
            } catch (Exception e) {
                Log.e("MainActivity", "Error sending login request", e);
                MainActivity.this.handleConnectionFailure();
            }
        }

        void m27lambda$onOpen$0$comexamplemyreaderMainActivity$1() {
            MainActivity.this.loadingText.setText("Отправка данных авторизации...");
        }

        public void onMessage(WebSocket webSocket, String text) {
            if (MainActivity.this.isCancelled) {
                return;
            }
            Log.d("MainActivity", "Received message: " + text);
            try {
                JSONObject response = new JSONObject(text);
                String cmd = response.getString("cmd");
                if ("login_response".equals(cmd)) {
                    if (response.getBoolean("success")) {
                        MainActivity.this.runOnUiThread(new Runnable() {
                            @Override
                            public final void run() {
                                MainActivity.AnonymousClass1.this.m24lambda$onMessage$1$comexamplemyreaderMainActivity$1();
                            }
                        });
                        final String token = response.getString(Constants.KEY_TOKEN);
                        SharedPreferences prefs = MainActivity.this.getSharedPreferences(Constants.PREF_NAME, 0);
                        prefs.edit().putString(Constants.KEY_TOKEN, token).putString("username", this.val$username).apply();
                        MainActivity.this.runOnUiThread(new Runnable() {
                            @Override
                            public final void run() {
                                MainActivity.AnonymousClass1.this.m25lambda$onMessage$2$comexamplemyreaderMainActivity$1(token);
                            }
                        });
                    } else {
                        final String message = response.getString("message");
                        Log.e("MainActivity", "Login failed: " + message);
                        MainActivity.this.runOnUiThread(new Runnable() {
                            @Override
                            public final void run() {
                                MainActivity.AnonymousClass1.this.m26lambda$onMessage$3$comexamplemyreaderMainActivity$1(message);
                            }
                        });
                    }
                }
            } catch (Exception e) {
                Log.e("MainActivity", "Error processing message", e);
                MainActivity.this.handleConnectionFailure();
            }
        }

        void m24lambda$onMessage$1$comexamplemyreaderMainActivity$1() {
            MainActivity.this.loadingText.setText("Авторизация успешна!");
            MainActivity.this.connectionStatus.setText("Подключено");
        }

        void m25lambda$onMessage$2$comexamplemyreaderMainActivity$1(String token) {
            Intent intent = new Intent((Context) MainActivity.this, (Class<?>) ReaderActivity.class);
            intent.putExtra(Constants.KEY_TOKEN, token);
            intent.putExtra("port", MainActivity.this.selectedPort);
            MainActivity.this.startActivity(intent);
            MainActivity.this.finish();
        }

        void m26lambda$onMessage$3$comexamplemyreaderMainActivity$1(String message) {
            MainActivity.this.loadingText.setText("Ошибка авторизации: " + message);
            MainActivity.this.connectionStatus.setText("Ошибка авторизации");
            Toast.makeText((Context) MainActivity.this, (CharSequence) message, 0).show();
            MainActivity.this.showPortButtons();
        }

        public void onFailure(WebSocket webSocket, final Throwable t, Response response) {
            if (MainActivity.this.isCancelled) {
                return;
            }
            Log.e("MainActivity", "WebSocket failure: " + t.getMessage(), t);
            MainActivity.this.runOnUiThread(new Runnable() {
                @Override
                public final void run() {
                    MainActivity.AnonymousClass1.this.m23lambda$onFailure$4$comexamplemyreaderMainActivity$1(t);
                }
            });
            MainActivity.this.handleConnectionFailure();
        }

        void m23lambda$onFailure$4$comexamplemyreaderMainActivity$1(Throwable t) {
            MainActivity.this.loadingText.setText("Ошибка подключения: " + t.getMessage());
            MainActivity.this.connectionStatus.setText("Ошибка подключения");
        }

        public void onClosing(WebSocket webSocket, int code, String reason) {
            if (MainActivity.this.isCancelled) {
                return;
            }
            Log.d("MainActivity", "WebSocket closing: " + reason);
            MainActivity.this.runOnUiThread(new Runnable() {
                @Override
                public final void run() {
                    MainActivity.AnonymousClass1.this.m22lambda$onClosing$5$comexamplemyreaderMainActivity$1();
                }
            });
        }

        void m22lambda$onClosing$5$comexamplemyreaderMainActivity$1() {
            MainActivity.this.loadingText.setText("Соединение закрывается...");
            MainActivity.this.connectionStatus.setText("Закрытие соединения");
        }

        public void onClosed(WebSocket webSocket, int code, String reason) {
            if (MainActivity.this.isCancelled) {
                return;
            }
            Log.d("MainActivity", "WebSocket closed: " + reason);
            MainActivity.this.runOnUiThread(new Runnable() {
                @Override
                public final void run() {
                    MainActivity.AnonymousClass1.this.m21lambda$onClosed$6$comexamplemyreaderMainActivity$1();
                }
            });
            if (code != 1000 && MainActivity.this.reconnectAttempts < MainActivity.MAX_RECONNECT_ATTEMPTS) {
                MainActivity.this.handleConnectionFailure();
            }
        }

        void m21lambda$onClosed$6$comexamplemyreaderMainActivity$1() {
            MainActivity.this.loadingText.setText("Соединение закрыто");
            MainActivity.this.connectionStatus.setText("Соединение закрыто");
        }
    }

    public void handleConnectionFailure() {
        if (this.isCancelled) {
            return;
        }
        int i = this.reconnectAttempts;
        if (i < MAX_RECONNECT_ATTEMPTS) {
            this.reconnectAttempts = i + 1;
            Log.d("MainActivity", "Connection failed, attempting reconnect " + this.reconnectAttempts + " of " + MAX_RECONNECT_ATTEMPTS);
            final int[] countdown = {MAX_RECONNECT_ATTEMPTS};
            runOnUiThread(new Runnable() {
                @Override
                public final void run() {
                    MainActivity.this.m15xb6bfdb0b(countdown);
                }
            });
            Runnable runnable = this.countdownRunnable;
            if (runnable != null) {
                this.countdownHandler.removeCallbacks(runnable);
            }
            AnonymousClass2 anonymousClass2 = new AnonymousClass2(countdown);
            this.countdownRunnable = anonymousClass2;
            this.countdownHandler.post(anonymousClass2);
            return;
        }
        runOnUiThread(new Runnable() {
            @Override
            public final void run() {
                MainActivity.this.m16x1d989acc();
            }
        });
    }

    void m15xb6bfdb0b(int[] countdown) {
        this.loadingText.setText(String.format("Переподключение...\nПовторная попытка через %d сек...", Integer.valueOf(countdown[0])));
        this.connectionStatus.setText(String.format("Попытка %d из %d", Integer.valueOf(this.reconnectAttempts), Integer.valueOf(MAX_RECONNECT_ATTEMPTS)));
    }

    class AnonymousClass2 implements Runnable {
        final int[] val$countdown;

        AnonymousClass2(int[] iArr) {
            this.val$countdown = iArr;
        }

        @Override
        public void run() {
            if (MainActivity.this.isCancelled) {
                return;
            }
            final int[] iArr = this.val$countdown;
            int i = iArr[0] - 1;
            iArr[0] = i;
            if (i > 0) {
                MainActivity.this.runOnUiThread(new Runnable() {
                    @Override
                    public final void run() {
                        MainActivity.AnonymousClass2.this.m28lambda$run$0$comexamplemyreaderMainActivity$2(iArr);
                    }
                });
                MainActivity.this.countdownHandler.postDelayed(this, 1000L);
            } else if (!MainActivity.this.isFinishing() && !MainActivity.this.isCancelled) {
                MainActivity mainActivity = MainActivity.this;
                mainActivity.login(mainActivity.currentUsername, MainActivity.this.currentPassword);
            }
        }

        void m28lambda$run$0$comexamplemyreaderMainActivity$2(int[] countdown) {
            MainActivity.this.loadingText.setText(String.format("Переподключение...\nПовторная попытка через %d сек...", Integer.valueOf(countdown[0])));
        }
    }

    void m16x1d989acc() {
        this.loadingText.setText(String.format("Не удалось подключиться\nпосле %d попыток", Integer.valueOf(MAX_RECONNECT_ATTEMPTS)));
        this.connectionStatus.setText("Достигнут лимит попыток");
        Toast.makeText((Context) this, (CharSequence) "Не удалось подключиться после 5 попыток", 0).show();
        showPortButtons();
    }

    public void showPortButtons() {
        this.progressBar.setVisibility(8);
        this.loadingText.setVisibility(8);
        this.connectionStatus.setVisibility(8);
        this.buttonContainer.setVisibility(8);
        this.btnPort1.setVisibility(0);
    }

    private boolean isTokenExpired(String token) {
        try {
            String[] split = token.split("\\.");
            String payload = new String(Base64.decode(split[1], 0), "UTF-8");
            JSONObject jsonObject = new JSONObject(payload);
            long exp = jsonObject.getLong("exp");
            long currentTime = System.currentTimeMillis() / 1000;
            return currentTime >= exp;
        } catch (Exception e) {
            e.printStackTrace();
            return true;
        }
    }

    protected void onDestroy() {
        super.onDestroy();
        this.isCancelled = true;
        WebSocket webSocket = this.webSocket;
        if (webSocket != null) {
            webSocket.close(1000, "Activity destroyed");
        }
        this.reconnectHandler.removeCallbacksAndMessages(null);
        Runnable runnable = this.countdownRunnable;
        if (runnable != null) {
            this.countdownHandler.removeCallbacks(runnable);
        }
    }
}