1091 lines
32 KiB
Java
1091 lines
32 KiB
Java
package com.safemobile.safedispatch;
|
|
|
|
import android.app.Activity;
|
|
import android.app.AlertDialog;
|
|
import android.app.Dialog;
|
|
import android.content.ComponentName;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.content.ServiceConnection;
|
|
import android.content.SharedPreferences;
|
|
import android.content.res.Configuration;
|
|
import android.graphics.Color;
|
|
import android.net.ConnectivityManager;
|
|
import android.net.Network;
|
|
import android.net.NetworkCapabilities;
|
|
import android.net.NetworkRequest;
|
|
import android.os.AsyncTask;
|
|
import android.os.Build;
|
|
import android.os.Bundle;
|
|
import android.os.Handler;
|
|
import android.os.IBinder;
|
|
import android.os.Looper;
|
|
import android.text.Editable;
|
|
import android.text.InputType;
|
|
import android.util.Log;
|
|
import android.view.Gravity;
|
|
import android.view.View;
|
|
import android.view.View.OnClickListener;
|
|
import android.view.Window;
|
|
import android.view.WindowManager;
|
|
import android.widget.Button;
|
|
import android.widget.CheckBox;
|
|
import android.widget.EditText;
|
|
import android.widget.ImageView;
|
|
import android.widget.LinearLayout;
|
|
import android.widget.RelativeLayout;
|
|
import android.widget.TextView;
|
|
import android.widget.Toast;
|
|
|
|
import com.safemobile.adapters.LanguageSpinnerAdapter;
|
|
import com.safemobile.interfaces.ITCPListener;
|
|
import com.safemobile.interfaces.TCPEvent;
|
|
import com.safemobile.lib.AppParams;
|
|
import com.safemobile.lib.AppParams.ActivityResult;
|
|
import com.safemobile.lib.Contact;
|
|
import com.safemobile.lib.LoginMSG;
|
|
import com.safemobile.lib.Radio;
|
|
import com.safemobile.lib.SM;
|
|
import com.safemobile.lib.TCPmsg;
|
|
import com.safemobile.lib.User;
|
|
import com.safemobile.lib.radio.Channel;
|
|
import com.safemobile.lib.radio.Emerg;
|
|
import com.safemobile.lib.radio.IncCall;
|
|
import com.safemobile.lib.radio.RadioStatus;
|
|
import com.safemobile.libpad.PadRecording;
|
|
import com.safemobile.libpad.PadTextMessage;
|
|
import com.safemobile.services.TCPService;
|
|
import com.safemobile.services.TCPService.TCPBinder;
|
|
import com.safemobile.services.TCPhandler;
|
|
import com.safemobile.services.TCPmsgParser;
|
|
|
|
import java.util.Locale;
|
|
import java.util.Timer;
|
|
import java.util.TimerTask;
|
|
|
|
public class SDMobileActivity extends Activity {
|
|
|
|
/* Visual Elements */
|
|
private Button btLogin;
|
|
private EditText etPassword;
|
|
private EditText etUsername;
|
|
private CheckBox checkBoxSaveDefault;
|
|
private RelativeLayout layoutTCP;
|
|
private LinearLayout llUsername;
|
|
private LinearLayout llPassword;
|
|
private ImageView imageLanguage;
|
|
|
|
/* Preferences */
|
|
private SharedPreferences.Editor editor;
|
|
|
|
/* Misc */
|
|
private String[] languages = {"English", "German", "Turkish", "Romanian", "Russian", "Spanish"};
|
|
private Context context;
|
|
private Activity activity;
|
|
private Dialog loadingDialog;
|
|
|
|
/* Handler for callbacks to the UI thread */
|
|
private final Handler uiHandler = new Handler(Looper.getMainLooper());
|
|
|
|
/* TCP */
|
|
protected TCPhandler tcp;
|
|
protected TCPmsgParser tcpParser;
|
|
protected ITCPListener itcpListener;
|
|
protected Timer timerLogin;//timer to check connection!!!
|
|
|
|
/**
|
|
* TCP Service
|
|
*/
|
|
private TCPService myService;
|
|
private boolean isBound = false;
|
|
|
|
/* User details */
|
|
protected int userID;// ID of logged in user
|
|
|
|
private Boolean prevTCPState = false;
|
|
|
|
/* Constants */
|
|
private static final String DATABASE_LANGUAGE = "en"; // database language : en, de, tr, ro or empty
|
|
private static final String LANGUAGE = "language";
|
|
private static final String USERNAME = "username";
|
|
private static final String PASSWORD = "password";
|
|
private static final String LOGIN = "login";
|
|
private static final String DEFAULT = "default";
|
|
|
|
/**
|
|
* Called when the activity is first created.
|
|
*/
|
|
@Override
|
|
public void onCreate(Bundle savedInstanceState) {
|
|
super.onCreate(savedInstanceState);
|
|
SM.Debug("##### onCREATE ##### with LANGUAGE " + AppParams.LANGUAGETMP);
|
|
|
|
ConnectivityManager connectivityManager =
|
|
(ConnectivityManager) this.getSystemService(Context.CONNECTIVITY_SERVICE);
|
|
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N)
|
|
connectivityManager.registerDefaultNetworkCallback(networkCallback);
|
|
else {
|
|
NetworkRequest request = new NetworkRequest.Builder()
|
|
.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET).build();
|
|
connectivityManager.registerNetworkCallback(request, networkCallback);
|
|
}
|
|
|
|
AppParams.theme = AppParams.Theme.SAFEDISPATCH;
|
|
if (AppParams.theme == AppParams.Theme.SAFENET)
|
|
this.setTheme(R.style.Theme_Safenet);
|
|
else if (AppParams.theme == AppParams.Theme.VISION)
|
|
this.setTheme(R.style.Theme_Vision);
|
|
else if (AppParams.theme == AppParams.Theme.HYTERA)
|
|
this.setTheme(R.style.Theme_Hytera);
|
|
else
|
|
this.setTheme(R.style.AppTheme);
|
|
|
|
// get Context
|
|
context = this;
|
|
activity = this;
|
|
|
|
// get settings
|
|
loadSettings();
|
|
|
|
// if package is demo set DEMO to true
|
|
AppParams.DEMO = (context.getPackageName().contains("demo"));
|
|
|
|
|
|
if (savedInstanceState != null && savedInstanceState.getString(LANGUAGE) != null)
|
|
// set language which will be used for displaying UI
|
|
AppParams.LANGUAGETMP = savedInstanceState.getString(LANGUAGE);
|
|
else
|
|
AppParams.LANGUAGETMP = AppParams.LANGUAGE;
|
|
|
|
Locale locale = new Locale(AppParams.LANGUAGETMP);
|
|
Locale.setDefault(locale);
|
|
Configuration config = new Configuration();
|
|
config.locale = locale;
|
|
getBaseContext().getResources().updateConfiguration(config,
|
|
getBaseContext().getResources().getDisplayMetrics());
|
|
|
|
languages = new String[]{getString(R.string.en), getString(R.string.de), getString(R.string.tr), getString(R.string.ro), getString(R.string.ru), getString(R.string.es)};
|
|
|
|
setContentView(R.layout.login_h);
|
|
|
|
// do not dim the display
|
|
getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
|
|
// hide keyboard when opening app
|
|
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
|
|
|
|
checkBoxSaveDefault = (CheckBox) findViewById(R.id.checkBoxSaveDefault);
|
|
// if username and password not equal N/A => save as default was checked
|
|
if (!AppParams.USERNAME.equals("n/a") && !AppParams.PASSWORD.equals("n/a"))
|
|
checkBoxSaveDefault.setChecked(true);
|
|
|
|
ImageView imageLoading = (ImageView) findViewById(R.id.imageLoading);
|
|
imageLoading.setBackgroundResource(R.drawable.loading);
|
|
|
|
// language
|
|
imageLanguage = (ImageView) findViewById(R.id.imageLanguage);
|
|
imageLanguage.setOnClickListener(LanguageListener);
|
|
setLanguageIcon();
|
|
|
|
// username and password
|
|
etUsername = (EditText) findViewById(R.id.etUsername);
|
|
etPassword = (EditText) findViewById(R.id.etPassword);
|
|
|
|
// login button
|
|
btLogin = (Button) findViewById(R.id.btLogin);
|
|
btLogin.setOnClickListener(arg0 -> {
|
|
|
|
if (AppParams.DEMO)
|
|
startTabActivity(0);
|
|
else {
|
|
if (etPassword.getText().toString().length() < 1 || etUsername.getText().toString().length() < 1)
|
|
showInfoDialog(getResources().getString(R.string.password));
|
|
else {
|
|
// if save username and password
|
|
// reset username and password
|
|
saveSettings(checkBoxSaveDefault.isChecked()); // save settings
|
|
|
|
if (!loadingDialog.isShowing())
|
|
loadingDialog.show();
|
|
|
|
// TODO get users list
|
|
new connectTask().execute(LOGIN);
|
|
}
|
|
}
|
|
|
|
});
|
|
|
|
ImageView imageSettings = (ImageView) findViewById(R.id.imageSettings);
|
|
imageSettings.setOnClickListener(changeIPListener);
|
|
|
|
// reset values before changing language
|
|
if (savedInstanceState != null && savedInstanceState.getString(USERNAME) != null) {
|
|
etUsername.setText(savedInstanceState.getString(USERNAME));
|
|
etPassword.setText(savedInstanceState.getString(PASSWORD));
|
|
checkBoxSaveDefault.setChecked(savedInstanceState.getBoolean("checked"));
|
|
} else {
|
|
// set values stored in Shared Preferences
|
|
etUsername.setText(AppParams.USERNAME.equalsIgnoreCase("n/a") ? "" : AppParams.USERNAME);
|
|
etPassword.setText(AppParams.PASSWORD.equalsIgnoreCase("n/a") ? "" : AppParams.PASSWORD);
|
|
}
|
|
|
|
layoutTCP = findViewById(R.id.layoutTCP);
|
|
|
|
llUsername = findViewById(R.id.llUsername);
|
|
llPassword = findViewById(R.id.llPassword);
|
|
|
|
// enable ui after the language is changed and tcp connection is on
|
|
if (tcp != null && tcp.isConnectionUP) {
|
|
layoutTCP.setVisibility(View.INVISIBLE);
|
|
enableUI(true);
|
|
}
|
|
// enable UI if application is demo
|
|
else if (AppParams.DEMO) {
|
|
enableUI(true);
|
|
layoutTCP.setVisibility(View.INVISIBLE);
|
|
} else
|
|
enableUI(false);
|
|
|
|
if (!AppParams.DEMO) {
|
|
/** Create Service and bind on it */
|
|
getApplicationContext().bindService(new Intent(this, TCPService.class), serviceConnection, Context.BIND_AUTO_CREATE);
|
|
}
|
|
|
|
createLoadingDialog(getString(R.string.checkingUser));
|
|
|
|
timerLogin = new Timer();
|
|
timerLogin.scheduleAtFixedRate(new TimerTask() {
|
|
@Override
|
|
public void run() {
|
|
// request to trigger the event because the first time when
|
|
// it was triggered, the listener wasn't created
|
|
if (tcp != null) {
|
|
tcp.triggerTCPConnectionStateEvent();
|
|
}
|
|
}
|
|
}, 1000, 500);
|
|
}
|
|
|
|
/* Enable and disable UI elements */
|
|
private void enableUI(boolean isEnabled) {
|
|
checkBoxSaveDefault.setEnabled(isEnabled);
|
|
btLogin.setEnabled(isEnabled);
|
|
etPassword.setEnabled(isEnabled);
|
|
etUsername.setEnabled(isEnabled);
|
|
|
|
// change username and password layout background to gray or white
|
|
if (isEnabled) {
|
|
llUsername.setBackgroundResource(R.drawable.textboxx);
|
|
llPassword.setBackgroundResource(R.drawable.textboxx);
|
|
} else {
|
|
llUsername.setBackgroundResource(R.drawable.textboxx);
|
|
llPassword.setBackgroundResource(R.drawable.textboxx);
|
|
}
|
|
}
|
|
|
|
|
|
private void setLanguageIcon()
|
|
{
|
|
// change spinner icon and selected language according to tmpLanguage
|
|
switch (AppParams.LANGUAGETMP) {
|
|
case "en":
|
|
imageLanguage.setImageResource(R.drawable.en);
|
|
break;
|
|
case "de":
|
|
imageLanguage.setImageResource(R.drawable.de);
|
|
break;
|
|
case "tr":
|
|
imageLanguage.setImageResource(R.drawable.tr);
|
|
break;
|
|
case "ro":
|
|
imageLanguage.setImageResource(R.drawable.ro);
|
|
break;
|
|
case "es":
|
|
imageLanguage.setImageResource(R.drawable.es);
|
|
break;
|
|
case "ru":
|
|
imageLanguage.setImageResource(R.drawable.ru);
|
|
break;
|
|
default:
|
|
throw new IllegalStateException("Unexpected value: " + AppParams.LANGUAGETMP);
|
|
}
|
|
|
|
}
|
|
|
|
@Override
|
|
public void onBackPressed() {
|
|
if (loadingDialog.isShowing())
|
|
cancelLoadingDialog();
|
|
else {
|
|
|
|
// show dialog that allows to select the close of the app
|
|
AlertDialog.Builder builder = new AlertDialog.Builder(this);
|
|
builder.setMessage(getString(R.string.exit))
|
|
.setCancelable(false)
|
|
.setPositiveButton(getString(R.string.yes), (dialog, id) -> whenBackPressed())
|
|
.setNegativeButton(getString(R.string.no), (dialog, id) -> dialog.cancel());
|
|
AlertDialog alert = builder.create();
|
|
alert.show();
|
|
}
|
|
}
|
|
|
|
/* Callback for connecting/disconnecting from the service that controls TCP Connections */
|
|
ServiceConnection serviceConnection = new ServiceConnection() {
|
|
|
|
@Override
|
|
public void onServiceDisconnected(ComponentName name) {
|
|
Toast.makeText(context, getString(R.string.serviceDisconnected), Toast.LENGTH_SHORT).show();
|
|
isBound = false;
|
|
}
|
|
|
|
@Override
|
|
public void onServiceConnected(ComponentName name, IBinder service) {
|
|
TCPBinder binder = (TCPBinder) service;
|
|
myService = binder.getService();
|
|
isBound = true;
|
|
}
|
|
};
|
|
|
|
@Override
|
|
public void onStop() {
|
|
super.onStop();
|
|
SM.Debug("##### onSTOP #####");
|
|
// Unbind from the service
|
|
if (isBound) {
|
|
getApplicationContext().unbindService(serviceConnection);
|
|
isBound = false;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onStart() {
|
|
super.onStart();
|
|
SM.Debug("##### onSTART #####");
|
|
|
|
if (AppParams.DEMO) {
|
|
etPassword.setText("demo");
|
|
etUsername.setText("demo");
|
|
}
|
|
|
|
if (loadingDialog != null)
|
|
loadingDialog.cancel();
|
|
|
|
// get Users only if IP and PORT are completed
|
|
if (tcp == null && !AppParams.IP.equals("n/a") && !AppParams.PORT.equals("n/a") && !AppParams.DEMO) {
|
|
new Thread(() -> {
|
|
try {
|
|
Thread.sleep(300);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
Thread.currentThread().interrupt();
|
|
}
|
|
uiHandler.post(initTCPRUN);
|
|
}).start();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
// this will be called when the user selects logout or exit
|
|
public void onActivityResult(int requestCode, int resultCode, Intent intent) {
|
|
final String TAG = "### RESULT ###";
|
|
if (requestCode == 0 && resultCode == RESULT_OK) {
|
|
ActivityResult result = (ActivityResult) intent.getSerializableExtra("result");
|
|
if (result == ActivityResult.logout) {
|
|
SM.Debug(TAG, "LOGOUT");
|
|
updateUIwithTCPStatus(true);
|
|
} else if (result == ActivityResult.restart) {
|
|
// check tcp status and set UI
|
|
if (myService != null)
|
|
tcp = myService.getTCPConnection();
|
|
|
|
SM.Debug(TAG, "RESTART");
|
|
|
|
/* authenticate again if tcp is ok */
|
|
Timer t = new Timer();
|
|
t.schedule(new TimerTask() {
|
|
@Override
|
|
public void run() {
|
|
uiHandler.post(() -> {
|
|
|
|
if (tcp != null && tcp.isConnectionUP) {
|
|
if (!loadingDialog.isShowing())
|
|
loadingDialog.show();
|
|
|
|
enableUI(true);
|
|
layoutTCP.setVisibility(View.INVISIBLE);
|
|
new connectTask().execute(LOGIN);
|
|
}
|
|
});
|
|
}
|
|
}, 1000);
|
|
} else if (result == ActivityResult.tcpDown) {
|
|
SM.Debug(TAG, "TCP DOWN");
|
|
updateUIwithTCPStatus(false);
|
|
} else if (result == ActivityResult.exit) {
|
|
SM.Debug(TAG, "EXIT");
|
|
whenBackPressed();
|
|
}
|
|
}
|
|
resetAppLists();
|
|
}
|
|
|
|
private void resetAppLists() {
|
|
SM.Exception("################ RESET ##############");
|
|
AppParams.listContacts.clear();
|
|
AppParams.listRecordings.clear();
|
|
AppParams.hashTextMessagesByRadioID.clear();
|
|
AppParams.listZones.clear();
|
|
AppParams.crtAckedTextMessage = new PadTextMessage();
|
|
AppParams.crtChannel = new Channel();
|
|
AppParams.crtContact = new Contact();
|
|
AppParams.crtEmergencyState = new Emerg();
|
|
AppParams.crtIncCall = new IncCall();
|
|
AppParams.crtRadio = new Radio();
|
|
AppParams.crtRadioStatus = new RadioStatus();
|
|
AppParams.crtReceivedTextMessage = new PadTextMessage();
|
|
AppParams.crtRecording = new PadRecording();
|
|
AppParams.crtSentTextMessage = new PadTextMessage();
|
|
}
|
|
|
|
|
|
private OnClickListener changeIPListener = new OnClickListener() {
|
|
@Override
|
|
public void onClick(View v) {
|
|
// show dialog
|
|
LinearLayout ll = new LinearLayout(context);
|
|
ll.setOrientation(LinearLayout.HORIZONTAL);
|
|
|
|
final EditText input = new EditText(activity);
|
|
input.setSelectAllOnFocus(true);
|
|
input.setText(AppParams.IP);
|
|
input.setMinWidth(190);
|
|
input.setHint(getString(R.string.hintIP));
|
|
input.setGravity(Gravity.CENTER);
|
|
|
|
ll.addView(input, 0);
|
|
|
|
final TextView tv = new TextView(context);
|
|
tv.setText(":");
|
|
tv.setTextColor(Color.WHITE);
|
|
ll.addView(tv, 1);
|
|
|
|
final EditText inputPort = new EditText(activity);
|
|
inputPort.setSelectAllOnFocus(true);
|
|
inputPort.setText(AppParams.PORT);
|
|
inputPort.setHint(getString(R.string.hintPort));
|
|
inputPort.setMinWidth(90);
|
|
inputPort.setInputType(InputType.TYPE_CLASS_NUMBER);
|
|
inputPort.setGravity(Gravity.CENTER);
|
|
ll.addView(inputPort, 2);
|
|
|
|
ll.setGravity(Gravity.CENTER);
|
|
|
|
new AlertDialog.Builder(activity)
|
|
.setTitle(getString(R.string.appServerIP))
|
|
.setMessage(getString(R.string.enterIPPort))
|
|
.setView(ll)
|
|
.setPositiveButton(getString(R.string.ok), (dialog, whichButton) -> {
|
|
Editable value = input.getText();
|
|
Editable valuePort = inputPort.getText();
|
|
|
|
try {
|
|
if (Integer.parseInt(valuePort.toString()) > 0 && Integer.parseInt(valuePort.toString()) < 65535)
|
|
saveIPandRestartTCP(value.toString(), valuePort.toString());
|
|
else
|
|
Toast.makeText(context, getString(R.string.invalidPort), Toast.LENGTH_SHORT).show();
|
|
} catch (Exception ex) {
|
|
Toast.makeText(context, getString(R.string.invalidPort), Toast.LENGTH_SHORT).show();
|
|
}
|
|
|
|
|
|
}).setNegativeButton(getString(R.string.cancel), (dialog, whichButton) -> {
|
|
// close dialog
|
|
dialog.dismiss();
|
|
|
|
// hide keyboard
|
|
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
|
|
|
|
}).show();
|
|
}
|
|
};
|
|
|
|
private void whenBackPressed() {
|
|
if (tcp != null) {
|
|
tcp.Stop();
|
|
if (tcpParser != null)
|
|
tcpParser.Stop();
|
|
}
|
|
|
|
cancelTimerLogin();
|
|
|
|
try {
|
|
getApplicationContext().unbindService(serviceConnection);
|
|
} catch (IllegalArgumentException ignored) {
|
|
//ignored
|
|
}
|
|
|
|
activity.finish();
|
|
android.os.Process.killProcess(android.os.Process.myPid());
|
|
System.exit(0);
|
|
}
|
|
|
|
// Create runnable for posting
|
|
final Runnable initTCPRUN = () -> {
|
|
// start thread to add listener
|
|
SM.Debug("##### initTCPRUN");
|
|
if (!AppParams.DEMO)
|
|
tcpInit();
|
|
};
|
|
|
|
@Override
|
|
public void onPause() {
|
|
super.onPause();
|
|
SM.Debug("##### onPAUSE #####");
|
|
}
|
|
|
|
@Override
|
|
public void onResume() {
|
|
super.onResume();
|
|
SM.Debug("##### onRESUME #####");
|
|
}
|
|
|
|
private final ConnectivityManager.NetworkCallback networkCallback = new ConnectivityManager.NetworkCallback() {
|
|
@Override
|
|
public void onAvailable(Network network) {
|
|
// network available
|
|
Log.v("NetworkAvailability", "available");
|
|
if (tcp != null && !tcp.isConnectionUP)
|
|
saveIPandRestartTCP(AppParams.IP, AppParams.PORT);
|
|
}
|
|
|
|
@Override
|
|
public void onLost(Network network) {
|
|
// network unavailable
|
|
Log.v("NetworkAvailability", "unavailable");
|
|
}
|
|
};
|
|
|
|
private void startTabActivity(long userID) {
|
|
// good login - load activity
|
|
Intent intent = new Intent(context, TabLayoutActivity.class);
|
|
|
|
// send parameters
|
|
intent.putExtra("userID", userID);
|
|
intent.putExtra(USERNAME, etUsername.getText().toString());
|
|
intent.putExtra(PASSWORD, etPassword.getText().toString());
|
|
|
|
AppParams.USERNAME = etUsername.getText().toString();
|
|
AppParams.PASSWORD = etPassword.getText().toString();
|
|
AppParams.USERID = userID;
|
|
|
|
if (!AppParams.DEMO && tcpParser != null && itcpListener != null) {
|
|
// unregister tcpParser
|
|
tcpParser.removeTCPListener(itcpListener);
|
|
}
|
|
|
|
// start activity
|
|
startActivityForResult(intent, 0);
|
|
}
|
|
|
|
private void updateUIwithTCPStatus(boolean enable) {
|
|
SM.Debug("UPDATE UI :" + enable);
|
|
if (enable)
|
|
layoutTCP.setVisibility(View.INVISIBLE);
|
|
else
|
|
layoutTCP.setVisibility(View.VISIBLE);
|
|
|
|
enableUI(enable);
|
|
}
|
|
|
|
// cancel loading dialog and show sending error message
|
|
private void cancelLoadingDialog() {
|
|
// cancel loading dialog
|
|
if (loadingDialog != null)
|
|
loadingDialog.cancel();
|
|
}
|
|
|
|
// this will cancel the timer that waits for the authenticating procedure to complete
|
|
private void cancelTimerLogin() {
|
|
if (timerLogin != null) {
|
|
timerLogin.cancel();
|
|
timerLogin = null;
|
|
}
|
|
}
|
|
|
|
// listener when select language pressed
|
|
private final OnClickListener LanguageListener = new OnClickListener() {
|
|
|
|
@Override
|
|
public void onClick(View v) {
|
|
final LanguageSpinnerAdapter adapter = new LanguageSpinnerAdapter(context, android.R.layout.simple_spinner_item, languages, getLayoutInflater());
|
|
AlertDialog.Builder builder = new AlertDialog.Builder(context);
|
|
builder.setTitle(getString(R.string.selLanguage));
|
|
builder.setAdapter(adapter, (dialog, which) -> {
|
|
Bundle saved = new Bundle();
|
|
saved.putString(USERNAME, etUsername.getText().toString());
|
|
saved.putString(PASSWORD, etPassword.getText().toString());
|
|
saved.putBoolean("checked", checkBoxSaveDefault.isChecked());
|
|
|
|
switch (which) {
|
|
case 0:
|
|
imageLanguage.setImageResource(R.drawable.en);
|
|
saved.putString(LANGUAGE, "en");
|
|
AppParams.LANGUAGETMP = "en";
|
|
AppParams.LANGUAGE = "en";
|
|
break;
|
|
case 1:
|
|
imageLanguage.setImageResource(R.drawable.de);
|
|
saved.putString(LANGUAGE, "de");
|
|
AppParams.LANGUAGETMP = "de";
|
|
AppParams.LANGUAGE = "de";
|
|
break;
|
|
case 2:
|
|
imageLanguage.setImageResource(R.drawable.tr);
|
|
saved.putString(LANGUAGE, "tr");
|
|
AppParams.LANGUAGETMP = "tr";
|
|
AppParams.LANGUAGE = "tr";
|
|
break;
|
|
case 3:
|
|
imageLanguage.setImageResource(R.drawable.ro);
|
|
saved.putString(LANGUAGE, "ro");
|
|
AppParams.LANGUAGETMP = "ro";
|
|
AppParams.LANGUAGE = "ro";
|
|
break;
|
|
case 4:
|
|
imageLanguage.setImageResource(R.drawable.ru);
|
|
saved.putString(LANGUAGE, "ru");
|
|
AppParams.LANGUAGETMP = "ru";
|
|
AppParams.LANGUAGE = "ru";
|
|
break;
|
|
case 5:
|
|
imageLanguage.setImageResource(R.drawable.es);
|
|
saved.putString(LANGUAGE, "es");
|
|
AppParams.LANGUAGETMP = "es";
|
|
AppParams.LANGUAGE = "es";
|
|
break;
|
|
default:
|
|
throw new IllegalStateException("Unexpected value: " + which);
|
|
}
|
|
|
|
// recreate the activity
|
|
onCreate(saved);
|
|
});
|
|
|
|
AlertDialog alert = builder.create();
|
|
alert.show();
|
|
}
|
|
};
|
|
|
|
private void tcpInit() {
|
|
int port = 0;
|
|
try {
|
|
port = Integer.parseInt(AppParams.PORT);
|
|
} catch (Exception ex) {
|
|
SM.Debug("PORT is not an integer");
|
|
}
|
|
//create TCP handle
|
|
SM.Debug("new TCP on IP: " + AppParams.IP + " | PORT: " + port);
|
|
|
|
// connect to the server
|
|
new connectTask().execute("tcp");
|
|
new connectParserTask().execute("");
|
|
}
|
|
|
|
// load settings
|
|
public void loadSettings() {
|
|
try {
|
|
// get Preferences for SafeDispatch
|
|
AppParams.prefs = getSharedPreferences(getPackageName(), MODE_PRIVATE);
|
|
// get default language
|
|
AppParams.LANGUAGE = AppParams.prefs.getString(LANGUAGE, DATABASE_LANGUAGE);
|
|
// get default username
|
|
AppParams.USERNAME = AppParams.prefs.getString(USERNAME, "n/a");
|
|
// get default password
|
|
AppParams.PASSWORD = AppParams.prefs.getString(PASSWORD, "n/a");
|
|
// get default IP
|
|
AppParams.IP = AppParams.prefs.getString("ip", "185.8.154.190");
|
|
|
|
// get Radio ID & IP
|
|
AppParams.RADIOID = AppParams.prefs.getInt("radioId", 100);
|
|
AppParams.RADIOIP = AppParams.prefs.getString("radioIp", "192.168.10.40");
|
|
|
|
// get default communication port
|
|
AppParams.PORT = AppParams.prefs.getString("port", "13589");
|
|
// get default value -> IP,PORT
|
|
AppParams.DEFAULT = AppParams.prefs.getString(DEFAULT, "0#0");
|
|
// get default sound source value
|
|
AppParams.SOURCE = AppParams.prefs.getString("source", "TCP");
|
|
|
|
|
|
SM.Debug("LOAD SETTINGS ### UserName: " + AppParams.USERNAME + " |Password: " + AppParams.PASSWORD
|
|
+ " |IP: " + AppParams.IP + " |PORT: " + AppParams.PORT + " | LANGUAGE: " + AppParams.LANGUAGE);
|
|
} catch (Exception ex) {
|
|
SM.Exception("Exception", "loadSettings exception");
|
|
}
|
|
}
|
|
|
|
public void saveSettings(boolean modify) {
|
|
// get editor
|
|
editor = AppParams.prefs.edit();
|
|
// put new values
|
|
editor.putString(LANGUAGE, AppParams.LANGUAGETMP);
|
|
editor.putString("languagetmp", AppParams.LANGUAGETMP);
|
|
// save new username and password
|
|
if (modify) {
|
|
if (etUsername.getText().toString().length() > 0)
|
|
editor.putString(USERNAME, etUsername.getText().toString());
|
|
else
|
|
editor.putString(USERNAME, "n/a");
|
|
|
|
if (etPassword.getText().toString().length() > 0)
|
|
editor.putString(PASSWORD, etPassword.getText().toString());
|
|
else
|
|
editor.putString(PASSWORD, "n/a");
|
|
|
|
// safe default -> ip#port
|
|
editor.putString(DEFAULT, AppParams.IP + "#" + AppParams.PORT);
|
|
} else // reset username and password
|
|
{
|
|
editor.putString(USERNAME, "n/a");
|
|
editor.putString(PASSWORD, "n/a");
|
|
editor.putString(DEFAULT, "0#0");
|
|
}
|
|
|
|
AppParams.USERNAME = etUsername.getText().toString();
|
|
AppParams.PASSWORD = etPassword.getText().toString();
|
|
SM.Debug("SAVE SETTINGS ### UserName: " + AppParams.USERNAME + " |Password: " + AppParams.PASSWORD
|
|
+ " |IP: " + AppParams.IP + " |PORT: " + AppParams.PORT);
|
|
editor.commit();
|
|
}
|
|
|
|
|
|
public void createLoadingDialog(String message) {
|
|
loadingDialog = new Dialog(context);
|
|
loadingDialog.requestWindowFeature(Window.FEATURE_NO_TITLE);
|
|
loadingDialog.setContentView(R.layout.dialogloading);
|
|
loadingDialog.setCancelable(true);
|
|
loadingDialog.setCanceledOnTouchOutside(false);
|
|
|
|
Button cancel = (Button) loadingDialog.findViewById(R.id.buttonCancel);
|
|
cancel.setVisibility(View.GONE);
|
|
TextView textView1 = (TextView) loadingDialog.findViewById(R.id.textView1);
|
|
textView1.setText(message);
|
|
}
|
|
|
|
public void showInfoDialog(String message) {
|
|
/* Dialog */
|
|
Dialog dialogInfo = new Dialog(context);
|
|
dialogInfo.requestWindowFeature(Window.FEATURE_NO_TITLE);
|
|
dialogInfo.setContentView(R.layout.dialog_login);
|
|
TextView textTitle = dialogInfo.findViewById(R.id.textTitle);
|
|
TextView text = dialogInfo.findViewById(R.id.text);
|
|
TextView text2 = dialogInfo.findViewById(R.id.text2);
|
|
ImageView image = dialogInfo.findViewById(R.id.image);
|
|
|
|
textTitle.setText(getString(R.string.connectionError));
|
|
image.setImageResource(R.drawable.error);
|
|
text.setText(getString(R.string.userPassError));
|
|
text2.setVisibility(View.GONE);
|
|
|
|
dialogInfo.setCancelable(true);
|
|
dialogInfo.setCanceledOnTouchOutside(true);
|
|
try {
|
|
dialogInfo.show();
|
|
} catch (Exception ex) {
|
|
ex.toString();
|
|
}
|
|
}
|
|
|
|
public void showErrorDialog(String title, String errorMsg) {
|
|
Dialog dialog = new Dialog(context);
|
|
dialog.requestWindowFeature(Window.FEATURE_NO_TITLE);
|
|
dialog.setContentView(R.layout.dialog_login);
|
|
dialog.setCancelable(true);
|
|
dialog.setCanceledOnTouchOutside(true);
|
|
|
|
TextView textTitle = (TextView) dialog.findViewById(R.id.textTitle);
|
|
textTitle.setText(title);
|
|
TextView text = (TextView) dialog.findViewById(R.id.text);
|
|
TextView text2 = (TextView) dialog.findViewById(R.id.text2);
|
|
text2.setVisibility(View.GONE);
|
|
ImageView image = (ImageView) dialog.findViewById(R.id.image);
|
|
|
|
image.setImageResource(R.drawable.error);
|
|
text.setText(errorMsg);
|
|
dialog.show();
|
|
}
|
|
|
|
private void saveIPandRestartTCP(String myIP, String port) {
|
|
// get IP
|
|
if (myIP.length() > 1)
|
|
AppParams.IP = myIP;
|
|
// get Preferences for SafeDispatch
|
|
// save net ip
|
|
editor = AppParams.prefs.edit();
|
|
// put new values
|
|
editor.putString("ip", AppParams.IP);
|
|
// get PORT
|
|
|
|
AppParams.PORT = port;
|
|
if (AppParams.PORT.length() < 1)
|
|
AppParams.PORT = "n/a";
|
|
// save port
|
|
editor.putString("port", AppParams.PORT);
|
|
editor.commit();
|
|
|
|
SM.Exception("TCP CHANGED WITH IP AND PORT " + myIP + " | " + port);
|
|
|
|
// if port or IP changed
|
|
if (!AppParams.DEMO) {
|
|
if (tcp != null) {
|
|
tcp.Stop();
|
|
if (tcpParser != null)
|
|
tcpParser.clearMsgList();
|
|
tcp = null;
|
|
}
|
|
|
|
uiHandler.post(() -> {
|
|
if (myService != null) {
|
|
myService.stopTCPConnection();
|
|
|
|
|
|
myService.recreateTCPConnection();
|
|
|
|
uiHandler.post(initTCPRUN);
|
|
}
|
|
SM.Debug("RECREATE TCP", "IP: " + AppParams.IP + " | Port: " + AppParams.PORT);
|
|
});
|
|
}
|
|
}
|
|
|
|
//tcp
|
|
public boolean getUsers() {
|
|
if (tcp == null)
|
|
return false;
|
|
|
|
if (Boolean.FALSE.equals(tcp.isConnectionUP))
|
|
return false;
|
|
|
|
boolean res = tcp.Write("0.0", "#20#");
|
|
if (res) {
|
|
SM.Debug("Message sent to app server");
|
|
} else {
|
|
SM.Debug("Could not send message!!");
|
|
}
|
|
return res;
|
|
}
|
|
|
|
public class connectTask extends AsyncTask<String, Void, TCPhandler> {
|
|
|
|
@Override
|
|
protected TCPhandler doInBackground(String... params) {
|
|
|
|
if (params[0].equals("tcp")) {
|
|
if (myService != null) {
|
|
tcp = myService.getTCPConnection();
|
|
}
|
|
} else if (params[0].equals(LOGIN)) {
|
|
getUsers();
|
|
|
|
// start a timer to display an error message if response isn't received
|
|
timerLogin = new Timer();
|
|
timerLogin.schedule(new TimerTask() {
|
|
@Override
|
|
public void run() {
|
|
uiHandler.post(() -> {
|
|
loadingDialog.cancel();
|
|
showErrorDialog("Login Error", "Could not receive response for login. Check connectivity and try again");
|
|
});
|
|
}
|
|
}, 10000);
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public class connectParserTask extends AsyncTask<String, Void, TCPhandler> {
|
|
@Override
|
|
protected TCPhandler doInBackground(String... params) {
|
|
if (myService != null)
|
|
tcpParser = myService.getTCPmsgParser();
|
|
|
|
// add TCPParserListener
|
|
if (tcpParser != null) {
|
|
tcpParser.clearITCPListeners();
|
|
tcpParser.addTCPListener(itcpListener = new ITCPListener() {
|
|
|
|
@Override
|
|
public void onLoginReceived(TCPEvent event) {
|
|
SM.Debug("LoginReceived", "LoginReceived");
|
|
TCPmsg msg = event.msg();
|
|
LoginMSG lMSG = new LoginMSG(msg);
|
|
|
|
SM.Debug("userList:" + lMSG.userList.size());
|
|
for (User u : lMSG.userList) {
|
|
SM.Debug("$$$$$$ user:" + u.login + " id:" + u.id + " pass:" + u.password);
|
|
}
|
|
|
|
// save received users
|
|
AppParams.allUsers = lMSG.userList;
|
|
|
|
boolean good = false; // remembers if username and password are good
|
|
for (User u : AppParams.allUsers)
|
|
if (u.login.equals(etUsername.getText().toString()) && etPassword.getText().toString().equals(u.password)) {
|
|
good = true; // flag good login
|
|
userID = u.id;
|
|
SM.Debug("Loged userID (LoginActivity):" + userID);
|
|
}
|
|
|
|
if (!good) {
|
|
SM.Debug("Invalid username or password");
|
|
// invalid username
|
|
uiHandler.post(() -> {
|
|
cancelLoadingDialog();
|
|
cancelTimerLogin();
|
|
showErrorDialog("Login Error", getString(R.string.invalidUser));
|
|
});
|
|
} else {
|
|
// clear tcp listener
|
|
tcpParser.removeTCPListener(itcpListener);
|
|
|
|
AppParams.USERNAME = etUsername.getText().toString();
|
|
AppParams.USERID = userID;
|
|
|
|
// login was successful so I can load Tab Activity
|
|
startTabActivity(userID);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onGPSReceived(TCPEvent event) {
|
|
}
|
|
|
|
@Override
|
|
public void onSMSReceived(TCPEvent event) {
|
|
}
|
|
|
|
@Override
|
|
public void onVehiclesReceived(TCPEvent event) {
|
|
}
|
|
|
|
@Override
|
|
public void onLastSMSsReceived(TCPEvent event) {
|
|
}
|
|
|
|
@Override
|
|
public void onSMSAckReceived(TCPEvent event) {
|
|
}
|
|
|
|
@Override
|
|
public void onNewSMSReceived(TCPEvent event) {
|
|
}
|
|
|
|
@Override
|
|
public void onLastPositionsReceived(TCPEvent event) {
|
|
}
|
|
|
|
@Override
|
|
public void onRadioMsgReceived(TCPEvent event) {
|
|
}
|
|
|
|
@Override
|
|
public void onHistoryPositionsReceived(TCPEvent event) {
|
|
}
|
|
|
|
@Override
|
|
public void onHistoryPositionsCountReceived(TCPEvent event) {
|
|
}
|
|
|
|
@Override
|
|
public void onAlarmsReceived(TCPEvent event) {
|
|
}
|
|
|
|
@Override
|
|
public void onAlarmAckReceived(TCPEvent event) {
|
|
}
|
|
|
|
@Override
|
|
public void alarmLiveReceived(TCPEvent event) {
|
|
}
|
|
|
|
@Override
|
|
public void onRecordingPlayReceived(TCPEvent event) {
|
|
}
|
|
|
|
@Override
|
|
public void onPollReceived(TCPEvent event) {
|
|
}
|
|
|
|
@Override
|
|
public void onConnectionReplyReceived(TCPEvent event) {
|
|
SM.Debug("Connection Ack Received", "##### Connection Ack Received #####");
|
|
}
|
|
|
|
@Override
|
|
public void onContactsListReceived(TCPEvent event) {
|
|
}
|
|
|
|
@Override
|
|
public void onRecordingsListReceived(TCPEvent event) {
|
|
}
|
|
|
|
@Override
|
|
public void onTextMessagesListReceived(TCPEvent event) {
|
|
}
|
|
|
|
@Override
|
|
public void onTCPConnectionDown(boolean previousWasConnectionUp) {
|
|
SM.Debug("TCP connection with:" + (tcp != null ? tcp.serverHostname : AppParams.RADIOIP) + ":"
|
|
+ (tcp != null ? tcp.getPort() : 0) + " is DOWN!!!");
|
|
// update ui only when a change happens with tcp connection
|
|
if (tcp != null && prevTCPState.equals(tcp.isConnectionUP))
|
|
uiHandler.post(() -> {
|
|
updateUIwithTCPStatus(false);
|
|
|
|
// cancel loading dialog if an authenticating procedure is going on
|
|
if (loadingDialog.isShowing()) {
|
|
cancelLoadingDialog();
|
|
cancelTimerLogin();
|
|
}
|
|
});
|
|
|
|
if (tcp != null)
|
|
prevTCPState = tcp.isConnectionUP;
|
|
|
|
// I can cancel the timer because I don't need for it to request the TCP status
|
|
// the listener is now created and it will handle all the events broadcast
|
|
cancelTimerLogin();
|
|
}
|
|
|
|
@Override
|
|
public void onTCPConnectionUp(boolean previousWasConnectionUp) {
|
|
SM.Debug("TCP connection with:" + (tcp != null ? tcp.serverHostname : AppParams.RADIOIP) + " is UP!!!");
|
|
// update state only if previous was offline
|
|
if (Boolean.TRUE.equals(!prevTCPState) || layoutTCP.getVisibility() == View.VISIBLE) {
|
|
uiHandler.post(() -> updateUIwithTCPStatus(true));
|
|
}
|
|
|
|
if (tcp != null)
|
|
prevTCPState = tcp.isConnectionUP;
|
|
|
|
// I can cancel the timer because I don't need for it to request the TCP status
|
|
// the listener is now created and it will handle all the events broadcasted
|
|
cancelTimerLogin();
|
|
}
|
|
|
|
@Override
|
|
public void onTCPConnectionStatusReceived(boolean isConnectionUp, boolean previousWasConnectionUp) {
|
|
|
|
}
|
|
|
|
@Override
|
|
public void onPONGReceived() {
|
|
// TODO Auto-generated method stub
|
|
}
|
|
});
|
|
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
} |