/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.systemui.statusbar.tablet;

import android.app.Notification;
import android.app.PendingIntent;
import android.app.Service;
import android.app.StatusBarManager;
import android.bluetooth.BluetoothAdapter;
import android.content.BroadcastReceiver;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.res.Resources;
import android.graphics.PixelFormat;
import android.graphics.Rect;
import android.location.LocationManager;
import android.media.AudioManager;
import android.net.NetworkInfo;
import android.net.wifi.SupplicantState;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.AsyncTask;
import android.os.Handler;
import android.os.IBinder;
import android.os.IPowerManager;
import android.os.Message;
import android.os.RemoteException;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.provider.Settings;
import android.telephony.PhoneStateListener;
import android.telephony.ServiceState;
import android.telephony.SignalStrength;
import android.telephony.TelephonyManager;
import android.util.AttributeSet;
import android.util.Slog;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.IWindowManager;
import android.view.WindowManager;
import android.view.WindowManagerImpl;
import android.widget.Button;
import android.widget.ImageButton;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.RemoteViews;
import android.widget.ScrollView;
import android.widget.TextSwitcher;
import android.widget.TextView;
import android.widget.Toast;

import java.util.List;

import com.android.internal.telephony.IccCard;
import com.android.internal.telephony.TelephonyIntents;
import com.android.internal.telephony.cdma.EriInfo;
import com.android.internal.telephony.cdma.TtyIntent;

import com.android.server.WindowManagerService;

import com.android.systemui.statusbar.*;
import com.android.systemui.R;

public class SystemPanel extends LinearLayout implements StatusBarPanel {
    private static final String TAG = "SystemPanel";
    private static final boolean DEBUG = TabletStatusBarService.DEBUG;
    private static final boolean DEBUG_SIGNAL = false;

    private static final int MINIMUM_BACKLIGHT = android.os.Power.BRIGHTNESS_DIM + 5;
    private static final int MAXIMUM_BACKLIGHT = android.os.Power.BRIGHTNESS_ON;
    private static final int DEFAULT_BACKLIGHT = (int) (android.os.Power.BRIGHTNESS_ON * 0.4f);

    private TabletStatusBarService mBar;
    private boolean mAirplaneMode;

    private ImageButton mBrightnessButton;
    private ImageButton mSoundButton;
    private ImageButton mOrientationButton;
    private ImageButton mAirplaneButton;
    private ImageButton mGpsButton;
    private ImageButton mBluetoothButton;

    private ImageView mBatteryMeter;
    private ImageView mSignalMeter;

    private TextView mBatteryText;
    private TextView mSignalText;

    private final IWindowManager mWM;

    private final AudioManager mAudioManager;
    private final WifiManager mWifiManager;
    private final TelephonyManager mPhone;
    private final BluetoothAdapter mBluetoothAdapter;

    // state trackers for telephony code
    IccCard.State mSimState = IccCard.State.READY;
    int mPhoneState = TelephonyManager.CALL_STATE_IDLE;
    int mDataState = TelephonyManager.DATA_DISCONNECTED;
    ServiceState mServiceState;
    SignalStrength mSignalStrength;

    // state for the meters
    boolean mWifiEnabled, mWifiConnected;
    int mWifiLevel;
    String mWifiSsid;

    boolean mDataEnabled, mDataConnected, mDataRoaming;
    int mDataLevel;

    public boolean isInContentArea(int x, int y) {
        final int l = getPaddingLeft();
        final int r = getWidth() - getPaddingRight();
        final int t = getPaddingTop();
        final int b = getHeight() - getPaddingBottom();
        return x >= l && x < r && y >= t && y < b;
    }

    private BroadcastReceiver mReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            final String action = intent.getAction();
            if (action.equals(AudioManager.RINGER_MODE_CHANGED_ACTION)) {
                refreshSound();
            } else if (action.equals(Intent.ACTION_BATTERY_CHANGED)) {
                updateBattery(intent);
            } else if (action.equals(WifiManager.RSSI_CHANGED_ACTION)
                    || action.equals(WifiManager.WIFI_STATE_CHANGED_ACTION)
                    || action.equals(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION)
                    || action.equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) {
                updateWifiState(intent);
            } else if (action.equals(TelephonyIntents.ACTION_SIM_STATE_CHANGED)) {
                updateSimState(intent);
            } else if (action.equals(BluetoothAdapter.ACTION_STATE_CHANGED)) {
                refreshBluetooth();
            }
        }
    };

    private final void updateSimState(Intent intent) {
        String stateExtra = intent.getStringExtra(IccCard.INTENT_KEY_ICC_STATE);
        if (IccCard.INTENT_VALUE_ICC_ABSENT.equals(stateExtra)) {
            mSimState = IccCard.State.ABSENT;
        }
        else if (IccCard.INTENT_VALUE_ICC_READY.equals(stateExtra)) {
            mSimState = IccCard.State.READY;
        }
        else if (IccCard.INTENT_VALUE_ICC_LOCKED.equals(stateExtra)) {
            final String lockedReason = intent.getStringExtra(IccCard.INTENT_KEY_LOCKED_REASON);
            if (IccCard.INTENT_VALUE_LOCKED_ON_PIN.equals(lockedReason)) {
                mSimState = IccCard.State.PIN_REQUIRED;
            }
            else if (IccCard.INTENT_VALUE_LOCKED_ON_PUK.equals(lockedReason)) {
                mSimState = IccCard.State.PUK_REQUIRED;
            }
            else {
                mSimState = IccCard.State.NETWORK_LOCKED;
            }
        } else {
            mSimState = IccCard.State.UNKNOWN;
        }
        updateDataState();
    }

    private boolean isCdma() {
        return (mSignalStrength != null) && !mSignalStrength.isGsm();
    }

    private boolean isEvdo() {
        return ( (mServiceState != null)
                 && ((mServiceState.getRadioTechnology()
                        == ServiceState.RADIO_TECHNOLOGY_EVDO_0)
                     || (mServiceState.getRadioTechnology()
                        == ServiceState.RADIO_TECHNOLOGY_EVDO_A)
                     || (mServiceState.getRadioTechnology()
                        == ServiceState.RADIO_TECHNOLOGY_EVDO_B)));
    }

    private boolean hasService() {
        if (mServiceState != null) {
            switch (mServiceState.getState()) {
                case ServiceState.STATE_OUT_OF_SERVICE:
                case ServiceState.STATE_POWER_OFF:
                    return false;
                default:
                    return true;
            }
        } else {
            return false;
        }
    }

    private int getCdmaLevel() {
        if (mSignalStrength == null) return 0;
        final int cdmaDbm = mSignalStrength.getCdmaDbm();
        final int cdmaEcio = mSignalStrength.getCdmaEcio();
        int levelDbm = 0;
        int levelEcio = 0;

        if (cdmaDbm >= -75) levelDbm = 4;
        else if (cdmaDbm >= -85) levelDbm = 3;
        else if (cdmaDbm >= -95) levelDbm = 2;
        else if (cdmaDbm >= -100) levelDbm = 1;
        else levelDbm = 0;

        // Ec/Io are in dB*10
        if (cdmaEcio >= -90) levelEcio = 4;
        else if (cdmaEcio >= -110) levelEcio = 3;
        else if (cdmaEcio >= -130) levelEcio = 2;
        else if (cdmaEcio >= -150) levelEcio = 1;
        else levelEcio = 0;

        return (levelDbm < levelEcio) ? levelDbm : levelEcio;
    }

    private int getEvdoLevel() {
        if (mSignalStrength == null) return 0;
        int evdoDbm = mSignalStrength.getEvdoDbm();
        int evdoSnr = mSignalStrength.getEvdoSnr();
        int levelEvdoDbm = 0;
        int levelEvdoSnr = 0;

        if (evdoDbm >= -65) levelEvdoDbm = 4;
        else if (evdoDbm >= -75) levelEvdoDbm = 3;
        else if (evdoDbm >= -90) levelEvdoDbm = 2;
        else if (evdoDbm >= -105) levelEvdoDbm = 1;
        else levelEvdoDbm = 0;

        if (evdoSnr >= 7) levelEvdoSnr = 4;
        else if (evdoSnr >= 5) levelEvdoSnr = 3;
        else if (evdoSnr >= 3) levelEvdoSnr = 2;
        else if (evdoSnr >= 1) levelEvdoSnr = 1;
        else levelEvdoSnr = 0;

        return (levelEvdoDbm < levelEvdoSnr) ? levelEvdoDbm : levelEvdoSnr;
    }

    private void updateDataState() {
        mDataConnected = hasService() && (mDataState == TelephonyManager.DATA_CONNECTED);

        if (isCdma()) {
            // these functions return a value from 0 to 4, inclusive
            if ((mPhoneState == TelephonyManager.CALL_STATE_IDLE) && isEvdo()){
                mDataLevel = getEvdoLevel() * 25;
            } else {
                mDataLevel = getCdmaLevel() * 25;
            }
        } else {
            // GSM
            
            int asu = (mSignalStrength == null) ? 0 : mSignalStrength.getGsmSignalStrength();

            // asu on [0,31]; 99 = unknown
            // Android has historically shown anything >=12 as "full"
            // XXX: tune this based on Industry Best Practices(TM)
            if (asu <= 2 || asu == 99) mDataLevel = 0;
            else mDataLevel = (int)(((float)Math.max(asu, 15) / 15) * 100);

            mDataRoaming = mPhone.isNetworkRoaming();

            mDataConnected = mDataConnected
                && (mSimState == IccCard.State.READY || mSimState == IccCard.State.UNKNOWN);
        }

        if (DEBUG_SIGNAL || DEBUG) {
            Slog.d(TAG, "updateDataState: connected=" + mDataConnected 
                    + " level=" + mDataLevel
                    + " isEvdo=" + isEvdo()
                    + " isCdma=" + isCdma()
                    + " mPhoneState=" + mPhoneState
                    + " mDataState=" + mDataState
                    );
        }

        refreshSignalMeters();
    }

    private void updateWifiState(Intent intent) {
        if (DEBUG)
            Slog.d(TAG, "updateWifiState: " + intent);

        final String action = intent.getAction();
        final boolean wasConnected = mWifiConnected;

        if (action.equals(WifiManager.WIFI_STATE_CHANGED_ACTION)) {
            mWifiEnabled = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE,
                    WifiManager.WIFI_STATE_UNKNOWN) == WifiManager.WIFI_STATE_ENABLED;
        } else if (action.equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) {
            final NetworkInfo networkInfo = (NetworkInfo)
                    intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
            mWifiConnected = networkInfo != null && networkInfo.isConnected();
        } else if (action.equals(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION)) {
            final NetworkInfo.DetailedState detailedState = WifiInfo.getDetailedStateOf(
                    (SupplicantState)intent.getParcelableExtra(WifiManager.EXTRA_NEW_STATE));
            mWifiConnected = detailedState == NetworkInfo.DetailedState.CONNECTED;
        } else if (action.equals(WifiManager.RSSI_CHANGED_ACTION)) {
            final int newRssi = intent.getIntExtra(WifiManager.EXTRA_NEW_RSSI, -200);
            int newSignalLevel = WifiManager.calculateSignalLevel(newRssi, 101);
            mWifiLevel = mWifiConnected ? newSignalLevel : 0;
        }

        if (mWifiConnected && !wasConnected) {
            WifiInfo info = mWifiManager.getConnectionInfo();
            if (DEBUG)
                Slog.d(TAG, "updateWifiState: just connected: info=" + info);

            if (info != null) {
                // grab the initial signal strength
                mWifiLevel = WifiManager.calculateSignalLevel(info.getRssi(), 101);

                // find the SSID
                mWifiSsid = info.getSSID();
                if (mWifiSsid == null) {
                    // OK, it's not in the connectionInfo; we have to go hunting for it
                    List<WifiConfiguration> networks = mWifiManager.getConfiguredNetworks();
                    for (WifiConfiguration net : networks) {
                        if (net.networkId == info.getNetworkId()) {
                            mWifiSsid = net.SSID;
                            break;
                        }
                    }
                }
            }
        }

        refreshSignalMeters();
    }

    // figure out what to show: first wifi, then 3G, then nothing
    void refreshSignalMeters() {
        if (mSignalMeter == null) return; // no UI yet

        Context ctxt = getContext();

        String text = null;
        int level = 0;

        if (mWifiConnected) {
            if (mWifiSsid == null) {
                text = ctxt.getString(R.string.system_panel_signal_meter_wifi_nossid);
            } else {
                text = ctxt.getString(R.string.system_panel_signal_meter_wifi_ssid_format,
                                      mWifiSsid);
            }
            level = mWifiLevel;
        } else if (mDataConnected) {
            text = ctxt.getString(R.string.system_panel_signal_meter_data_connected);
            level = mDataLevel;
        } else {
            text = ctxt.getString(R.string.system_panel_signal_meter_disconnected);
            level = 0;
        }

        mSignalMeter.setImageResource(R.drawable.sysbar_signal);
        mSignalMeter.setImageLevel(level);
        mSignalText.setText(text);

        // hack for now
        mBar.setSignalMeter(level, mWifiConnected);
    }

    public void setBar(TabletStatusBarService bar) {
        mBar = bar;
    }

    public void updateBattery(Intent intent) {
        final int level = intent.getIntExtra("level", 0);
        final boolean plugged = intent.getIntExtra("plugged", 0) != 0;

        mBatteryMeter.setImageResource(R.drawable.sysbar_battery);
        mBatteryMeter.setImageLevel(level);
        mBatteryText.setText(getContext()
                .getString(R.string.system_panel_battery_meter_format, level));

        // hack for now
        mBar.setBatteryMeter(level, plugged);
    }
    
    public SystemPanel(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public SystemPanel(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);

        // our mighty overlord
        mWM = IWindowManager.Stub.asInterface(
                    ServiceManager.getService("window"));


        // get notified of phone state changes
        TelephonyManager telephonyManager =
                (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
        telephonyManager.listen(mPhoneStateListener,
                          PhoneStateListener.LISTEN_SERVICE_STATE
                        | PhoneStateListener.LISTEN_SIGNAL_STRENGTHS
                        | PhoneStateListener.LISTEN_CALL_STATE
                        | PhoneStateListener.LISTEN_DATA_CONNECTION_STATE
                        | PhoneStateListener.LISTEN_DATA_ACTIVITY);

        // wifi status info
        mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        
        // audio status 
        mAudioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);

        // mobile data 
        mPhone = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE);

        // Bluetooth
        mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
    }

    public void onAttachedToWindow() {
        TextView settingsButton = (TextView)findViewById(R.id.settings_button);
        settingsButton.setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {
                getContext().startActivity(new Intent(android.provider.Settings.ACTION_SETTINGS)
                        .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK));
                mBar.animateCollapse();
            }});

        mBrightnessButton = (ImageButton)findViewById(R.id.brightness);
        mBrightnessButton.setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {
                rotateBrightness();
            }
        });

        mSoundButton = (ImageButton)findViewById(R.id.sound);
        mSoundButton.setAlpha(getSilentMode() ? 0x7F : 0xFF);
        mSoundButton.setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {
                setSilentMode(!getSilentMode());
                mSoundButton.setAlpha(getSilentMode() ? 0x7F : 0xFF);
            }
        });
        mOrientationButton = (ImageButton)findViewById(R.id.orientation);
        mOrientationButton.setImageResource(
            getAutoRotate()
                ? R.drawable.ic_sysbar_rotate_on
                : R.drawable.ic_sysbar_rotate_off);
        mOrientationButton.setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {
                setAutoRotate(!getAutoRotate());
                mOrientationButton.setImageResource(
                    getAutoRotate()
                        ? R.drawable.ic_sysbar_rotate_on
                        : R.drawable.ic_sysbar_rotate_off);
                Toast.makeText(getContext(), 
                    getAutoRotate() 
                        ? R.string.toast_rotation_free
                        : R.string.toast_rotation_locked,
                    Toast.LENGTH_SHORT).show();
            }
        });

        mAirplaneButton = (ImageButton)findViewById(R.id.airplane);
        mAirplaneButton.setAlpha(mAirplaneMode ? 0xFF : 0x7F);
        mAirplaneButton.setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {
                boolean newMode = !getAirplaneMode();
                Toast.makeText(getContext(), "Attempting to turn "
                    + (newMode ? "on" : "off") + " airplane mode (flaky).",
                    Toast.LENGTH_SHORT).show();
                setAirplaneMode(newMode);
            }
        });

        mGpsButton = (ImageButton)findViewById(R.id.gps);
        mGpsButton.setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {
                toggleGps();
                refreshGps();
            }
        });

        mBluetoothButton = (ImageButton)findViewById(R.id.bluetooth);
        mBluetoothButton.setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {
                toggleBluetooth();
                refreshBluetooth();
            }
        });

        // register for broadcasts
        IntentFilter filter = new IntentFilter();
        filter.addAction(AudioManager.RINGER_MODE_CHANGED_ACTION);
        filter.addAction(Intent.ACTION_BATTERY_CHANGED);
        filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
        filter.addAction(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION);
        filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
        filter.addAction(WifiManager.RSSI_CHANGED_ACTION);
        filter.addAction(TelephonyIntents.ACTION_SIM_STATE_CHANGED);
        filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
        getContext().registerReceiver(mReceiver, filter);
        
        mBatteryMeter = (ImageView)findViewById(R.id.battery_meter);
        mBatteryMeter.setImageResource(R.drawable.sysbar_battery);
        mBatteryMeter.setImageLevel(0);
        mSignalMeter = (ImageView)findViewById(R.id.signal_meter);
        mBatteryMeter.setImageResource(R.drawable.sysbar_signal);
        mBatteryMeter.setImageLevel(0);

        mBatteryText = (TextView)findViewById(R.id.battery_info);
        mSignalText = (TextView)findViewById(R.id.signal_info);

        refreshSignalMeters();
        refreshBluetooth();
        refreshGps();
    }

    public void onDetachedFromWindow() {
        getContext().unregisterReceiver(mReceiver);
    }

    // ----------------------------------------------------------------------

//    private boolean isAutoBrightness() {
//        Context context = getContext();
//        try {
//            IPowerManager power = IPowerManager.Stub.asInterface(
//                    ServiceManager.getService("power"));
//            if (power != null) {
//                int brightnessMode = Settings.System.getInt(context.getContentResolver(),
//                        Settings.System.SCREEN_BRIGHTNESS_MODE);
//                return brightnessMode == Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC;
//            }
//        } catch (RemoteException e) {
//        } catch (Settings.SettingNotFoundException e) {
//        }
//        return false;
//    }

    private void rotateBrightness() {
        int icon = R.drawable.ic_sysbar_brightness;
        int bg = R.drawable.sysbar_toggle_bg_on;
        Context context = getContext();
        try {
            IPowerManager power = IPowerManager.Stub.asInterface(
                    ServiceManager.getService("power"));
            if (power != null) {
                ContentResolver cr = context.getContentResolver();
                int brightness = Settings.System.getInt(cr,
                        Settings.System.SCREEN_BRIGHTNESS);
                int brightnessMode = Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL;
                //Only get brightness setting if available
                if (context.getResources().getBoolean(
                        com.android.internal.R.bool.config_automatic_brightness_available)) {
                    brightnessMode = Settings.System.getInt(cr,
                            Settings.System.SCREEN_BRIGHTNESS_MODE);
                }

                // Rotate AUTO -> MINIMUM -> DEFAULT -> MAXIMUM
                // Technically, not a toggle...
                if (brightnessMode == Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC) {
                    brightness = MINIMUM_BACKLIGHT;
                    icon = R.drawable.ic_sysbar_brightness_low;
                    brightnessMode = Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL;
                } else if (brightness < DEFAULT_BACKLIGHT) {
                    brightness = DEFAULT_BACKLIGHT;
                } else if (brightness < MAXIMUM_BACKLIGHT) {
                    brightness = MAXIMUM_BACKLIGHT;
                } else {
                    brightnessMode = Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC;
                    brightness = MINIMUM_BACKLIGHT;
                    icon = R.drawable.ic_sysbar_brightness_auto;
                }

                if (context.getResources().getBoolean(
                        com.android.internal.R.bool.config_automatic_brightness_available)) {
                    // Set screen brightness mode (automatic or manual)
                    Settings.System.putInt(context.getContentResolver(),
                            Settings.System.SCREEN_BRIGHTNESS_MODE,
                            brightnessMode);
                } else {
                    // Make sure we set the brightness if automatic mode isn't available
                    brightnessMode = Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL;
                }
                if (brightnessMode == Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL) {
                    power.setBacklightBrightness(brightness);
                    Settings.System.putInt(cr, Settings.System.SCREEN_BRIGHTNESS, brightness);
                }
            }
        } catch (RemoteException e) {
        } catch (Settings.SettingNotFoundException e) {
        }

        mBrightnessButton.setImageResource(icon);
        mBrightnessButton.setBackgroundResource(bg);
    }

    PhoneStateListener mPhoneStateListener = new PhoneStateListener() {
        @Override
        public void onServiceStateChanged(ServiceState serviceState) {
            if (DEBUG_SIGNAL || DEBUG) {
                Slog.d(TAG, "phone service state changed: " + serviceState.getState());
            }
            mServiceState = serviceState;
            mAirplaneMode = serviceState.getState() == ServiceState.STATE_POWER_OFF;
            if (mAirplaneButton != null) {
                mAirplaneButton.setImageResource(mAirplaneMode 
                                                 ? R.drawable.ic_sysbar_airplane_on
                                                 : R.drawable.ic_sysbar_airplane_off);
                mAirplaneButton.setBackgroundResource(mAirplaneMode 
                                                 ? R.drawable.sysbar_toggle_bg_on
                                                 : R.drawable.sysbar_toggle_bg_off);
            }
            updateDataState();
        }
        @Override
        public void onSignalStrengthsChanged(SignalStrength signalStrength) {
            if (DEBUG_SIGNAL || DEBUG) {
                Slog.d(TAG, "onSignalStrengthsChanged: " + signalStrength);
            }
            mSignalStrength = signalStrength;
            updateDataState();
        }
        @Override
        public void onCallStateChanged(int state, String incomingNumber) {
            mPhoneState = state;
            // In cdma, if a voice call is made, RSSI should switch to 1x.
            if (isCdma()) {
                updateDataState();
            }
        }

        @Override
        public void onDataConnectionStateChanged(int state, int networkType) {
            if (DEBUG_SIGNAL || DEBUG) {
                Slog.d(TAG, "onDataConnectionStateChanged: state=" + state 
                        + " type=" + networkType);
            }
            mDataState = state;
//            updateDataNetType(networkType);
            updateDataState();
        }
    };

    private boolean getAirplaneMode() {
        return mAirplaneMode;
    }

    private void setAirplaneMode(boolean on) {
        Settings.System.putInt(
                mContext.getContentResolver(),
                Settings.System.AIRPLANE_MODE_ON,
                on ? 1 : 0);
        Intent intent = new Intent(Intent.ACTION_AIRPLANE_MODE_CHANGED);
        intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING);
        intent.putExtra("state", on);
        getContext().sendBroadcast(intent);
    }

    boolean getSilentMode() {
        return mAudioManager.getRingerMode() != AudioManager.RINGER_MODE_NORMAL;
    }

    void setSilentMode(boolean on) {
        if (on) {
            mAudioManager.setRingerMode((Settings.System.getInt(mContext.getContentResolver(),
                Settings.System.VIBRATE_IN_SILENT, 1) == 1)
                ? AudioManager.RINGER_MODE_VIBRATE
                : AudioManager.RINGER_MODE_SILENT);
        } else {
            mAudioManager.setRingerMode(AudioManager.RINGER_MODE_NORMAL);
        }
    }

    void refreshSound() {
        boolean silent = getSilentMode();
        mSoundButton.setImageResource(!silent 
                                         ? R.drawable.ic_sysbar_sound_on
                                         : R.drawable.ic_sysbar_sound_off);
        mSoundButton.setBackgroundResource(!silent 
                                         ? R.drawable.sysbar_toggle_bg_on
                                         : R.drawable.sysbar_toggle_bg_off);
    }

    void toggleBluetooth() {
        if (mBluetoothAdapter == null) return;
        if (mBluetoothAdapter.isEnabled()) {
            mBluetoothAdapter.disable();
        } else {
            mBluetoothAdapter.enable();
        }
    }

    void refreshBluetooth() {
        boolean on = mBluetoothAdapter != null && mBluetoothAdapter.isEnabled();
        mBluetoothButton.setImageResource(on ? R.drawable.ic_sysbar_bluetooth_on
                                             : R.drawable.ic_sysbar_bluetooth_off);
        mBluetoothButton.setBackgroundResource(on
                                         ? R.drawable.sysbar_toggle_bg_on
                                         : R.drawable.sysbar_toggle_bg_off);
    }

    private boolean isGpsEnabled() {
        ContentResolver res = mContext.getContentResolver();
        return Settings.Secure.isLocationProviderEnabled(
                                res, LocationManager.GPS_PROVIDER);
    }

    private void toggleGps() {
        Settings.Secure.setLocationProviderEnabled(mContext.getContentResolver(),
                LocationManager.GPS_PROVIDER, !isGpsEnabled());
    }

    private void refreshGps() {
        boolean on = isGpsEnabled();
        mGpsButton.setImageResource(on ? R.drawable.ic_sysbar_gps_on
                                       : R.drawable.ic_sysbar_gps_off);
        mGpsButton.setBackgroundResource(on
                                         ? R.drawable.sysbar_toggle_bg_on
                                         : R.drawable.sysbar_toggle_bg_off);
    }

    void setAutoRotate(boolean rot) {
        try {
            ContentResolver cr = getContext().getContentResolver();
            if (rot) {
                mWM.thawRotation();
            } else {
                mWM.freezeRotation();
            }
        } catch (android.os.RemoteException exc) {
        }
    }

    boolean getAutoRotate() {
        ContentResolver cr = getContext().getContentResolver();
        return 1 == Settings.System.getInt(cr,
                Settings.System.ACCELEROMETER_ROTATION,
                1);
    }

    int getDisplayRotation() {
        try {
            return mWM.getRotation();
        } catch (android.os.RemoteException exc) {
            return 0;
        }
    }
}