/*
LinphonePreferencesActivity.java
Copyright (C) 2010  Belledonne Communications, Grenoble, France

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

package org.linphone;

import static org.linphone.R.string.ec_calibrating;
import static org.linphone.R.string.pref_codec_amr_key;
import static org.linphone.R.string.pref_codec_amrwb_key;
import static org.linphone.R.string.pref_codec_ilbc_key;
import static org.linphone.R.string.pref_codec_speex16_key;
import static org.linphone.R.string.pref_echo_cancellation_key;
import static org.linphone.R.string.pref_echo_canceller_calibration_key;
import static org.linphone.R.string.pref_echo_limiter_key;
import static org.linphone.R.string.pref_media_encryption_key;
import static org.linphone.R.string.pref_video_enable_key;

import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.linphone.LinphoneManager.EcCalibrationListener;
import org.linphone.LinphoneManager.LinphoneConfigException;
import org.linphone.core.LinphoneCore;
import org.linphone.core.LinphoneCore.EcCalibratorStatus;
import org.linphone.core.LinphoneCore.MediaEncryption;
import org.linphone.core.LinphoneCoreException;
import org.linphone.core.Log;
import org.linphone.mediastream.Version;
import org.linphone.mediastream.video.capture.hwconf.AndroidCameraConfiguration;
import org.linphone.mediastream.video.capture.hwconf.Hacks;

import android.app.AlertDialog;
import android.app.Dialog;
import android.content.Intent;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.os.Handler;
import android.preference.CheckBoxPreference;
import android.preference.ListPreference;
import android.preference.Preference;
import android.preference.Preference.OnPreferenceChangeListener;
import android.preference.Preference.OnPreferenceClickListener;
import android.preference.PreferenceActivity;
import android.preference.PreferenceCategory;
import android.preference.PreferenceScreen;
import android.text.Editable;
import android.text.TextWatcher;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.TextView;
import de.timroes.axmlrpc.XMLRPCCallback;
import de.timroes.axmlrpc.XMLRPCClient;
import de.timroes.axmlrpc.XMLRPCException;
import de.timroes.axmlrpc.XMLRPCServerException;

public class LinphonePreferencesActivity extends PreferenceActivity implements EcCalibrationListener {
	private Handler mHandler = new Handler();
	private CheckBoxPreference ecCalibratePref;
	private CheckBoxPreference elPref;
	private CheckBoxPreference ecPref;
	private ListPreference mencPref;
	private int nbAccounts = 1;
	
	// Wizard fields
	private boolean usernameOk = false;
	private boolean passwordOk = false;
	private boolean emailOk = false;
	private AlertDialog wizardDialog;
	private Button createAccount;
	private TextView errorMessage;
	private PreferenceCategory accounts;
	private String username;
	
	private static final int ADD_SIP_ACCOUNT = 0x666;
	private static final int WIZARD_ID = 0x667;
	private static final int CONFIRM_ID = 0x668;

	private SharedPreferences prefs() {
		return getPreferenceManager().getSharedPreferences();
	}

	private CheckBoxPreference findCheckbox(int key) {
		return (CheckBoxPreference) findPreference(getString(key));
	}

	private void detectAudioCodec(int id, String mime, int rate, boolean hide) {
		boolean enable = LinphoneService.isReady() && LinphoneManager.getLc().findPayloadType(mime, rate)!=null;
		Preference cb = findPreference(id);
		cb.setEnabled(enable);
		if (hide && !enable) {
			cb.setLayoutResource(R.layout.hidden);
		}
	}

	private void detectVideoCodec(int id, String mime) {
		findPreference(id).setEnabled(LinphoneManager.getInstance().detectVideoCodec(mime));
	}

	private void createDynamicAccountsPreferences() {
		PreferenceScreen root = getPreferenceScreen();
		
		// Get the good preference screen
		accounts = (PreferenceCategory) root.getPreference(0);
		accounts.removeAll();
		
		Preference addAccount = (Preference) root.getPreference(1);
		addAccount.setOnPreferenceClickListener(new OnPreferenceClickListener() {
	        public boolean onPreferenceClick(Preference preference) {
	        	addExtraAccountPreferencesButton(accounts, nbAccounts, true);
	        	Intent i = new Intent();
				i.putExtra("Account",nbAccounts);
	        	nbAccounts++;
				i.setClass(LinphonePreferencesActivity.this, LinphonePreferencesSIPAccountActivity.class);
				startActivityForResult(i, ADD_SIP_ACCOUNT);
	        	return true;
	        }
        });
		
		// Get already configured extra accounts
		SharedPreferences prefs = getPreferenceManager().getSharedPreferences();
		nbAccounts = prefs.getInt(getString(R.string.pref_extra_accounts), 0);
		for (int i = 0; i < nbAccounts; i++) {
			// For each, add menus to configure it
			addExtraAccountPreferencesButton(accounts, i, false);
		}
	}
	
	public int getNbAccountsExtra() {
		return nbAccounts;
	}
	
	private void addExtraAccountPreferencesButton(PreferenceCategory parent, final int n, boolean isNewAccount) {
		SharedPreferences prefs = getPreferenceManager().getSharedPreferences();
		if (isNewAccount) {
			SharedPreferences.Editor editor = prefs.edit();
			editor.putInt(getString(R.string.pref_extra_accounts), n+1);
			editor.commit();
		}
		
		Preference me = new Preference(LinphonePreferencesActivity.this);
		String keyUsername = getString(R.string.pref_username_key);
		String keyDomain = getString(R.string.pref_domain_key);
		if (n > 0) {
			keyUsername += n + "";
			keyDomain += n + "";
		}
		if (prefs.getString(keyUsername, null) == null) {
			me.setTitle(getString(R.string.pref_sipaccount));
		} else {
			me.setTitle(prefs.getString(keyUsername, "") + "@" + prefs.getString(keyDomain, ""));
		}
		
		me.setOnPreferenceClickListener(new OnPreferenceClickListener() 
		{
			public boolean onPreferenceClick(Preference preference) {
				Intent i = new Intent();
				i.putExtra("Account", n);
				i.setClass(LinphonePreferencesActivity.this, LinphonePreferencesSIPAccountActivity.class);
				startActivityForResult(i, ADD_SIP_ACCOUNT);
				return false;
			}
		});
		parent.addPreference(me);
	}
	
	private void fillLinphoneAccount(int i, String username, String password, boolean createdByWizard) {
		SharedPreferences prefs = getPreferenceManager().getSharedPreferences();
		SharedPreferences.Editor editor = prefs.edit();
		
		editor.putString(getString(R.string.pref_username_key) + i, username);
		editor.putString(getString(R.string.pref_passwd_key) + i, password);
		editor.putString(getString(R.string.pref_domain_key) + i, "sip.linphone.org");
		editor.putString(getString(R.string.pref_proxy_key) + i, "");
		editor.putBoolean(getString(R.string.pref_wizard_key) + i, createdByWizard);
		editor.putBoolean(getString(R.string.pref_activated_key) + i, false);
		editor.putBoolean(getString(R.string.pref_enable_outbound_proxy_key) + i, false);
		
		editor.commit();
	}
	
	protected void onActivityResult(int requestCode, int resultCode, Intent data) {
		super.onActivityResult(requestCode, resultCode, data);
		
		if (requestCode == ADD_SIP_ACCOUNT) {
			//Verify if last created account is filled
			SharedPreferences prefs = getPreferenceManager().getSharedPreferences();
			int n = prefs.getInt(getString(R.string.pref_extra_accounts), 1);
			String keyUsername = getString(R.string.pref_username_key) + (n-1 == 0 ? "" : Integer.toString(n-1));
			
			if (prefs.getString(keyUsername, "").equals("")) {
				//If not, we suppress it to not display a blank field
				SharedPreferences.Editor editor = prefs.edit();
				editor.putInt(getString(R.string.pref_extra_accounts), n-1);
				editor.commit();
			}
			
			createDynamicAccountsPreferences();
		}
	}
	
	private void addWizardPreferenceButton() {
		Preference wizard = (Preference) getPreferenceScreen().getPreference(2);
		wizard.setOnPreferenceClickListener(new OnPreferenceClickListener() {
	        public boolean onPreferenceClick(Preference preference) {
	        	showDialog(WIZARD_ID);
	        	return true;
	        }
        });
	}
	
	protected Dialog onCreateDialog (int id) {
		if (id == WIZARD_ID) {
			AlertDialog.Builder builder = new AlertDialog.Builder(LinphonePreferencesActivity.this);
	    	LayoutInflater inflater = LayoutInflater.from(LinphonePreferencesActivity.this);
	    	View v = inflater.inflate(R.layout.wizard, null);
	    	builder.setView(v);
	    	
	    	final EditText username = (EditText) v.findViewById(R.id.wizardUsername);
	    	ImageView usernameOkIV = (ImageView) v.findViewById(R.id.wizardUsernameOk);
	    	addXMLRPCUsernameHandler(username, usernameOkIV);

	    	final EditText password = (EditText) v.findViewById(R.id.wizardPassword);
	    	EditText passwordConfirm = (EditText) v.findViewById(R.id.wizardPasswordConfirm);
	    	ImageView passwordOkIV = (ImageView) v.findViewById(R.id.wizardPasswordOk);
	    	addXMLRPCPasswordHandler(password, passwordConfirm, passwordOkIV);

	    	final EditText email = (EditText) v.findViewById(R.id.wizardEmail);
	    	ImageView emailOkIV = (ImageView) v.findViewById(R.id.wizardEmailOk);
	    	addXMLRPCEmailHandler(email, emailOkIV);

	    	errorMessage = (TextView) v.findViewById(R.id.wizardErrorMessage);
	    	
	    	Button cancel = (Button) v.findViewById(R.id.wizardCancel);
	    	cancel.setOnClickListener(new OnClickListener() {
				public void onClick(View v) {
					wizardDialog.dismiss();
				}
	    	});
	    	
	    	createAccount = (Button) v.findViewById(R.id.wizardCreateAccount);
	    	createAccount.setOnClickListener(new OnClickListener() {
				public void onClick(View v) {
					createAccount(username.getText().toString(), password.getText().toString(), email.getText().toString(), false);
				}
	    	});
			createAccount.setEnabled(false);
	    	
	    	builder.setTitle(getString(R.string.wizard_title));
	    	wizardDialog = builder.create();
	    	return wizardDialog;
		}
		else if (id == CONFIRM_ID) {
			AlertDialog.Builder builder = new AlertDialog.Builder(LinphonePreferencesActivity.this);
			builder.setTitle(R.string.wizard_confirmation);
			
			final LayoutInflater inflater = LayoutInflater.from(LinphonePreferencesActivity.this);
	    	View v = inflater.inflate(R.layout.wizard_confirm, null);
	    	builder.setView(v);
	    	
	    	Button check = (Button) v.findViewById(R.id.wizardCheckAccount);
	    	check.setOnClickListener(new OnClickListener() {
				public void onClick(View v) {
					wizardDialog.dismiss();
					if (isAccountVerified(username)) {
						SharedPreferences prefs = getPreferenceManager().getSharedPreferences();
						SharedPreferences.Editor editor = prefs.edit();
						editor.putBoolean(getString(R.string.pref_activated_key) + (nbAccounts - 1), true);
						editor.commit();
					} else {
						showDialog(CONFIRM_ID);
					}
				}
			});
	    	
	    	Button cancel = (Button) v.findViewById(R.id.wizardCancel);
	    	cancel.setOnClickListener(new OnClickListener() {
				public void onClick(View v) {
					wizardDialog.dismiss();
				}
			});
	    	
			wizardDialog = builder.create();
			return wizardDialog;
		}
		return null;
	}
	
	private boolean isUsernameCorrect(String username) {
		return username.matches("^[a-zA-Z]+[a-zA-Z0-9.\\-_]{2,}$");
	}
	
	static boolean isAccountVerified(String username) {
		try {
			XMLRPCClient client = new XMLRPCClient(new URL("https://www.linphone.org/wizard.php"));
		    Object resultO = client.call("check_account_validated", "sip:" + username + "@sip.linphone.org");
		    Integer result = Integer.parseInt(resultO.toString());
		    
		    return result == 1;
		} catch(Exception ex) {

		}
		return false;
	}
	
	private void isUsernameRegistred(String username, final ImageView icon) {
		final Runnable runNotReachable = new Runnable() {
			public void run() {
				errorMessage.setText(R.string.wizard_server_unavailable);
				usernameOk = false;
				icon.setImageResource(R.drawable.notok);
				createAccount.setEnabled(usernameOk && passwordOk && emailOk);
			}
		};
		
		try {
			XMLRPCClient client = new XMLRPCClient(new URL("https://www.linphone.org/wizard.php"));
			
			XMLRPCCallback listener = new XMLRPCCallback() {
				Runnable runNotOk = new Runnable() {
    				public void run() {
    					errorMessage.setText(R.string.wizard_username_unavailable);
    					usernameOk = false;
						icon.setImageResource(R.drawable.notok);
						createAccount.setEnabled(usernameOk && passwordOk && emailOk);
					}
	    		};
	    		
	    		Runnable runOk = new Runnable() {
    				public void run() {
    					errorMessage.setText("");
    					icon.setImageResource(R.drawable.ok);
						usernameOk = true;
						createAccount.setEnabled(usernameOk && passwordOk && emailOk);
					}
	    		};
				
			    public void onResponse(long id, Object result) {
			    	int answer = (Integer) result;
			    	if (answer != 0) {
			    		runOnUiThread(runNotOk);
					}
					else {
						runOnUiThread(runOk);
					}
			    }
			    
			    public void onError(long id, XMLRPCException error) {
			    	runOnUiThread(runNotReachable);
			    }
			   
			    public void onServerError(long id, XMLRPCServerException error) {
			    	runOnUiThread(runNotReachable);
			    }
			};

		    client.callAsync(listener, "check_account", username);
		} 
		catch(Exception ex) {
			runOnUiThread(runNotReachable);
		}
	}
	
	private boolean isEmailCorrect(String email) {
		return email.matches("^[a-z0-9]+([_\\.-][a-z0-9]+)*@([a-z0-9]+([\\.-][a-z0-9]+)*)+\\.[a-z]{2,}$");
	}
	
	private boolean isPasswordCorrect(String password) {
		return password.length() >= 6;
	}
	
	private void createAccount(final String username, final String password, String email, boolean suscribe) {
		final Runnable runNotReachable = new Runnable() {
			public void run() {
				errorMessage.setText(R.string.wizard_server_unavailable);
			}
		};
		
		try {
			XMLRPCClient client = new XMLRPCClient(new URL("https://www.linphone.org/wizard.php"));
			
			XMLRPCCallback listener = new XMLRPCCallback() {
				Runnable runNotOk = new Runnable() {
    				public void run() {
    					errorMessage.setText(R.string.wizard_failed);
					}
	    		};
	    		
	    		Runnable runOk = new Runnable() {
    				public void run() {
			    		addExtraAccountPreferencesButton(accounts, nbAccounts, true);
			    		LinphonePreferencesActivity.this.username = username;
			    		fillLinphoneAccount(nbAccounts, username, password, true);
			        	nbAccounts++;
			    		createDynamicAccountsPreferences();
			    		wizardDialog.dismiss();
			    		
			    		showDialog(CONFIRM_ID);
					}
	    		};
	    		
			    public void onResponse(long id, Object result) {
			    	int answer = (Integer) result;
			    	if (answer != 0) {
			    		runOnUiThread(runNotOk);
			    	} else {
			    		runOnUiThread(runOk);
			    	}
			    }
			    
			    public void onError(long id, XMLRPCException error) {
			    	runOnUiThread(runNotReachable);
			    }
			   
			    public void onServerError(long id, XMLRPCServerException error) {
			    	runOnUiThread(runNotReachable);
			    }
			};

		    client.callAsync(listener, "create_account", username, password, email, suscribe ? 1 : 0);
		} 
		catch(Exception ex) {
			runOnUiThread(runNotReachable);
		}
	}
	
	private void addXMLRPCUsernameHandler(final EditText field, final ImageView icon) {
		field.addTextChangedListener(new TextWatcher() {
			public void afterTextChanged(Editable arg0) {
				
			}

			public void beforeTextChanged(CharSequence arg0, int arg1,
					int arg2, int arg3) {
				
			}

			public void onTextChanged(CharSequence arg0, int arg1, int arg2,
					int arg3) 
			{
				usernameOk = false;
				if (isUsernameCorrect(field.getText().toString()))
				{
					isUsernameRegistred(field.getText().toString(), icon);
				}
				else {
					errorMessage.setText(R.string.wizard_username_incorrect);
					icon.setImageResource(R.drawable.notok);
				}
			}
		});
	}
	
	private void addXMLRPCEmailHandler(final EditText field, final ImageView icon) {
		field.addTextChangedListener(new TextWatcher() {
			public void afterTextChanged(Editable arg0) {
				
			}

			public void beforeTextChanged(CharSequence arg0, int arg1,
					int arg2, int arg3) {
				
			}

			public void onTextChanged(CharSequence arg0, int arg1, int arg2,
					int arg3) 
			{
				emailOk = false;
				if (isEmailCorrect(field.getText().toString())) {
					icon.setImageResource(R.drawable.ok);
					emailOk = true;
					errorMessage.setText("");
				}
				else {
					errorMessage.setText(R.string.wizard_email_incorrect);
					icon.setImageResource(R.drawable.notok);
				}
				createAccount.setEnabled(usernameOk && passwordOk && emailOk);
			}
		});
	}
	
	private void addXMLRPCPasswordHandler(final EditText field1, final EditText field2, final ImageView icon) {
		TextWatcher passwordListener = new TextWatcher() {
			public void afterTextChanged(Editable arg0) {
				
			}

			public void beforeTextChanged(CharSequence arg0, int arg1,
					int arg2, int arg3) {
				
			}

			public void onTextChanged(CharSequence arg0, int arg1, int arg2,
					int arg3) 
			{
				passwordOk = false;
				if (isPasswordCorrect(field1.getText().toString()) && field1.getText().toString().equals(field2.getText().toString())) {
					passwordOk = true;
					icon.setImageResource(R.drawable.ok);
					errorMessage.setText("");
				}
				else {
					if (isPasswordCorrect(field1.getText().toString())) {
						errorMessage.setText(R.string.wizard_passwords_unmatched);
					}
					else {
						errorMessage.setText(R.string.wizard_password_incorrect);
					}
					icon.setImageResource(R.drawable.notok);
				}
				createAccount.setEnabled(usernameOk && passwordOk && emailOk);
			}
		};
		
		field1.addTextChangedListener(passwordListener);
		field2.addTextChangedListener(passwordListener);
	}
	
	private void verifiyAccountsActivated() {
		SharedPreferences prefs = getPreferenceManager().getSharedPreferences();
		for (int i = 0; i < nbAccounts; i++) {
			String key = (i == 0 ? "" : Integer.toString(i));
			boolean createdByWizard = prefs.getBoolean(getString(R.string.pref_wizard_key) + key, false);
			boolean activated = prefs.getBoolean(getString(R.string.pref_activated_key) + key, true);
			if (createdByWizard && !activated) {
				//Check if account has been activated since
				activated = isAccountVerified(prefs.getString(getString(R.string.pref_username_key) + key, ""));
				if (activated) {
					SharedPreferences.Editor editor = prefs.edit();
					editor.putBoolean(getString(R.string.pref_activated_key) + key, true);
					editor.commit();
				} else {
					showDialog(CONFIRM_ID);
				}
			}
		}
	}
	
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		// Load the preferences from an XML resource
		addPreferencesFromResource(R.xml.preferences);

		createDynamicAccountsPreferences();
		addWizardPreferenceButton();
		addTransportChecboxesListener();
		
		verifiyAccountsActivated();
		
		ecCalibratePref = (CheckBoxPreference) findPreference(pref_echo_canceller_calibration_key);
		ecCalibratePref.setOnPreferenceClickListener(new OnPreferenceClickListener() {
			public boolean onPreferenceClick(Preference preference) {
				startEcCalibration();
				return false;
			}
		});
		ecPref = (CheckBoxPreference) findPreference(pref_echo_cancellation_key);
		elPref = (CheckBoxPreference) findPreference(pref_echo_limiter_key);
		mencPref = (ListPreference) findPreference(pref_media_encryption_key);

		boolean fastCpu = Version.isArmv7();
		if (fastCpu) {
			detectAudioCodec(pref_codec_ilbc_key, "iLBC", 8000, false);
			findPreference(pref_codec_speex16_key).setEnabled(true);
			//findPreference(pref_codec_speex32_key)).setEnabled(enableIlbc);
			findPreference(pref_echo_cancellation_key).setEnabled(true);
		}else{
			findPreference(pref_echo_limiter_key).setEnabled(true);
		}

		initializeMediaEncryptionPreferences();
	
		detectAudioCodec(pref_codec_amr_key,"AMR", 8000, false);
        detectAudioCodec(pref_codec_amrwb_key,"AMR-WB", 16000, false);
		//detectAudioCodec(R.string.pref_codec_silk8_key,"SILK",8000, true);
		//detectAudioCodec(R.string.pref_codec_silk12_key,"SILK",12000, true);
		detectAudioCodec(R.string.pref_codec_silk16_key,"SILK",16000, true);
		detectAudioCodec(R.string.pref_codec_silk24_key,"SILK",24000, true);

		// No video
		if (!Version.isVideoCapable()) {
			uncheckAndDisableCheckbox(pref_video_enable_key);
		} else if (!AndroidCameraConfiguration.hasFrontCamera()) {
			uncheckDisableAndHideCheckbox(R.string.pref_video_use_front_camera_key);
		}

		if (prefs().getBoolean(LinphoneActivity.PREF_FIRST_LAUNCH,true)) {
			doOnFirstLaunch();
		}
		if (Hacks.hasBuiltInEchoCanceller()) {
			uncheckDisableAndHideCheckbox(R.string.pref_echo_limiter_key);
			uncheckDisableAndHideCheckbox(R.string.pref_echo_cancellation_key);
			uncheckDisableAndHideCheckbox(R.string.pref_echo_canceller_calibration_key);
		}


		detectVideoCodec(R.string.pref_video_codec_h264_key, "H264");

		addEchoPrefsListener();
		
		if (Hacks.needSoftvolume()) checkAndDisableCheckbox(R.string.pref_audio_soft_volume_key);

		if (!LinphoneManager.getLc().isTunnelAvailable()){
			hidePreferenceCategory(R.string.pref_tunnel_key);
		}
	}

	private void hidePreferenceCategory(int key) {
		PreferenceCategory p = (PreferenceCategory) findPreference(key);
		p.removeAll();
		p.setLayoutResource(R.layout.hidden);
	}

	private void doOnFirstLaunch() {
		manageCheckbox(R.string.pref_echo_limiter_key, !Hacks.hasBuiltInEchoCanceller(), true, false);
		prefs().edit().putBoolean(LinphoneActivity.PREF_FIRST_LAUNCH, false).commit();
	}

	private void initializeMediaEncryptionPreferences() {
		LinphoneCore lc=LinphoneManager.getLc();
		boolean hasZrtp=lc.mediaEncryptionSupported(MediaEncryption.ZRTP);
		boolean hasSrtp=lc.mediaEncryptionSupported(MediaEncryption.SRTP);
		if (!hasSrtp && !hasZrtp){
			mencPref.setEnabled(false);
		}else{
			List<CharSequence> mencEntries=new ArrayList<CharSequence>();
			List<CharSequence> mencEntryValues=new ArrayList<CharSequence>();
			mencEntries.add(getString(R.string.media_encryption_none));
			mencEntryValues.add(getString(R.string.pref_media_encryption_key_none));
			if (hasSrtp){
				mencEntries.add(getString(R.string.media_encryption_srtp));
				mencEntryValues.add(getString(R.string.pref_media_encryption_key_srtp));
			}
			if (hasZrtp){
				mencEntries.add(getString(R.string.media_encryption_zrtp));
				mencEntryValues.add(getString(R.string.pref_media_encryption_key_zrtp));
			}
			CharSequence[] contents=new CharSequence[mencEntries.size()];
			mencEntries.toArray(contents);
			mencPref.setEntries(contents);
			contents=new CharSequence[mencEntryValues.size()];
			mencEntryValues.toArray(contents);
			mencPref.setEntryValues(contents);
			mencPref.setDefaultValue(getString(R.string.media_encryption_none));
			//mencPref.setValueIndex(mencPref.findIndexOfValue(getString(R.string.media_encryption_none)));
		}
	}

	private void addEchoPrefsListener(){
		OnPreferenceChangeListener ec_listener=new OnPreferenceChangeListener(){
			public boolean onPreferenceChange(Preference arg0, Object newValue) {
				Boolean val=(Boolean)newValue;
				if (val){
					elPref.setChecked(!val);
				}
				return true;
			}
		};
		OnPreferenceChangeListener el_listener=new OnPreferenceChangeListener(){
			public boolean onPreferenceChange(Preference arg0, Object newValue) {
				Boolean val=(Boolean)newValue;
				if (val){
					ecPref.setChecked(!val);
				}
				return true;
			}
		};
		ecPref.setOnPreferenceChangeListener(ec_listener);
		elPref.setOnPreferenceChangeListener(el_listener);
	}

	private void addTransportChecboxesListener() {

		final List<CheckBoxPreference> checkboxes = Arrays.asList(
				findCheckbox(R.string.pref_transport_udp_key)
				,findCheckbox(R.string.pref_transport_tcp_key)
				,findCheckbox(R.string.pref_transport_tls_key)
				);
		

		OnPreferenceChangeListener changedListener = new OnPreferenceChangeListener() {
			public boolean onPreferenceChange(Preference preference, Object newValue) {
				if ((Boolean) newValue) {
					for (CheckBoxPreference p : checkboxes) {
						if (p == preference) continue;
						p.setChecked(false);
					}
					return true;
				} else {
					for (CheckBoxPreference p : checkboxes) {
						if (p == preference) continue;
						if (p.isChecked()) return true;
					}
					return false;
				}
			}
		};
		
		OnPreferenceClickListener clickListener = new OnPreferenceClickListener() {
			public boolean onPreferenceClick(Preference preference) {
				// Forbid no protocol selection
				
				if (((CheckBoxPreference) preference).isChecked()) {
					// Trying to unckeck
					for (CheckBoxPreference p : checkboxes) {
						if (p == preference) continue;
						if (p.isChecked()) return false;
					}
					/*Toast.makeText(LinphonePreferencesActivity.this,
							getString(R.string.at_least_a_protocol),
							Toast.LENGTH_SHORT).show();*/
					return true;
				}
				return false;
			}
		};

		for (CheckBoxPreference c : checkboxes) {
			c.setOnPreferenceChangeListener(changedListener);
			c.setOnPreferenceClickListener(clickListener);
		}
	}

	private synchronized void startEcCalibration() {
		try {
			LinphoneManager.getInstance().startEcCalibration(this);

			ecCalibratePref.setSummary(ec_calibrating);
			ecCalibratePref.getEditor().putBoolean(getString(pref_echo_canceller_calibration_key), false).commit();
		} catch (LinphoneCoreException e) {
			Log.w(e, "Cannot calibrate EC");
		}	
	}

	public void onEcCalibrationStatus(final EcCalibratorStatus status, final int delayMs) {

		mHandler.post(new Runnable() {
			public void run() {
				if (status == EcCalibratorStatus.Done) {
					ecCalibratePref.setSummary(String.format(getString(R.string.ec_calibrated), delayMs));
					ecCalibratePref.setChecked(true);

				} else if (status == EcCalibratorStatus.Failed) {
					ecCalibratePref.setSummary(R.string.failed);
					ecCalibratePref.setChecked(false);
					elPref.setChecked(true);
					ecPref.setChecked(false);
				}
			}
		});
	}

	private void uncheckDisableAndHideCheckbox(int key) { 
		manageCheckbox(key, false, false, true);
	}

	private void uncheckAndDisableCheckbox(int key) {
		manageCheckbox(key, false, false, false);
	}
	private void checkAndDisableCheckbox(int key) {
		manageCheckbox(key, true, false, false);
	}
	private void manageCheckbox(int key, boolean value, boolean enabled, boolean hidden) {
		CheckBoxPreference box = (CheckBoxPreference) findPreference(key);
		box.setEnabled(enabled);
		box.setChecked(value);
		writeBoolean(key, value);
		if (hidden) box.setLayoutResource(R.layout.hidden);
	}

	private Preference findPreference(int key) {
		return getPreferenceManager().findPreference(getString(key));
	}

	private void writeBoolean(int key, boolean value) {
		prefs().edit().putBoolean(getString(key), value).commit();
	}

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

		if (!isFinishing()) return;

		LinphoneCore lc = LinphoneManager.getLcIfManagerNotDestroyedOrNull();
		
		if (lc != null && (lc.isInComingInvitePending() || lc.isIncall())) {
			Log.w("Call in progress => settings not applied");
			return;
		}

		try {
			LinphoneManager.getInstance().initFromConf();
		} catch (LinphoneException e) {
			if (! (e instanceof LinphoneConfigException)) {
				Log.e(e, "Cannot update config");
				return;
			}

			LinphoneActivity.instance().showPreferenceErrorDialog(e.getMessage());
		}
	}

}