package net.androgames.blog.sample.orientation;
 
public interface OrientationListener {
 
    public void onOrientationChanged(float azimuth, 
            float pitch, float roll);
 
    /**
     * Top side of the phone is up
     * The phone is standing on its bottom side
     */
    public void onTopUp();
 
    /**
     * Bottom side of the phone is up
     * The phone is standing on its top side
     */
    public void onBottomUp();
 
    /**
     * Right side of the phone is up
     * The phone is standing on its left side
     */
    public void onRightUp();
 
    /**
     * Left side of the phone is up
     * The phone is standing on its right side
     */
    public void onLeftUp();
 
}

package net.androgames.blog.sample.orientation;
 
import java.util.List;
 
import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
 
/**
 * Android Orientation Sensor Manager Archetype
 * @author antoine vianey
 * under GPL v3 : http://www.gnu.org/licenses/gpl-3.0.html
 */
public class OrientationManager {
 
    private static Sensor sensor;
    private static SensorManager sensorManager;
    // you could use an OrientationListener array instead
    // if you plans to use more than one listener
    private static OrientationListener listener;
 
    /** indicates whether or not Orientation Sensor is supported */
    private static Boolean supported;
    /** indicates whether or not Orientation Sensor is running */
    private static boolean running = false;
 
    /** Sides of the phone */
    enum Side {
        TOP,
        BOTTOM,
        LEFT,
        RIGHT;
    }
 
    /**
     * Returns true if the manager is listening to orientation changes
     */
    public static boolean isListening() {
        return running;
    }
 
    /**
     * Unregisters listeners
     */
    public static void stopListening() {
        running = false;
        try {
            if (sensorManager != null && sensorEventListener != null) {
                sensorManager.unregisterListener(sensorEventListener);
            }
        } catch (Exception e) {}
    }
 
    /**
     * Returns true if at least one Orientation sensor is available
     */
    public static boolean isSupported() {
        if (supported == null) {
            if (Orientation.getContext() != null) {
                sensorManager = (SensorManager) Orientation.getContext()
                        .getSystemService(Context.SENSOR_SERVICE);
                List<Sensor> sensors = sensorManager.getSensorList(
                        Sensor.TYPE_ORIENTATION);
                supported = new Boolean(sensors.size() > 0);
            } else {
                supported = Boolean.FALSE;
            }
        }
        return supported;
    }
 
    /**
     * Registers a listener and start listening
     */
    public static void startListening(
            OrientationListener orientationListener) {
        sensorManager = (SensorManager) Orientation.getContext()
                .getSystemService(Context.SENSOR_SERVICE);
        List<Sensor> sensors = sensorManager.getSensorList(
                Sensor.TYPE_ORIENTATION);
        if (sensors.size() > 0) {
            sensor = sensors.get(0);
            running = sensorManager.registerListener(
                    sensorEventListener, sensor, 
                    SensorManager.SENSOR_DELAY_NORMAL);
            listener = orientationListener;
        }
    }
 
    /**
     * The listener that listen to events from the orientation listener
     */
    private static SensorEventListener sensorEventListener = 
        new SensorEventListener() {
 
        /** The side that is currently up */
        private Side currentSide = null;
        private Side oldSide = null;
        private float azimuth;
        private float pitch;
        private float roll;
 
        public void onAccuracyChanged(Sensor sensor, int accuracy) {}
 
        public void onSensorChanged(SensorEvent event) {
 
            azimuth = event.values[0];     // azimuth
            pitch = event.values[1];     // pitch
            roll = event.values[2];        // roll
 
            if (pitch < -45 && pitch > -135) {
                // top side up
                currentSide = Side.TOP;
            } else if (pitch > 45 && pitch < 135) {
                // bottom side up
                currentSide = Side.BOTTOM;
            } else if (roll > 45) {
                // right side up
                currentSide = Side.RIGHT;
            } else if (roll < -45) {
                // left side up
                currentSide = Side.LEFT;
            }
 
            if (currentSide != null && !currentSide.equals(oldSide)) {
                switch (currentSide) {
                    case TOP : 
                        listener.onTopUp();
                        break;
                    case BOTTOM : 
                        listener.onBottomUp();
                        break;
                    case LEFT: 
                        listener.onLeftUp();
                        break;
                    case RIGHT: 
                        listener.onRightUp();
                        break;
                }
                oldSide = currentSide;
            }
 
            // forwards orientation to the OrientationListener
            listener.onOrientationChanged(azimuth, pitch, roll);
        }
 
    };
 
}

package net.androgames.blog.sample.orientation;
 
import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.widget.TextView;
import android.widget.Toast;
 
/**
 * Android orientation sensor tutorial
 * @author antoine vianey
 * under GPL v3 : http://www.gnu.org/licenses/gpl-3.0.html
 */
public class Orientation extends Activity implements OrientationListener {
 
    private static Context CONTEXT;
 
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        CONTEXT = this;
    }
 
    protected void onResume() {
        super.onResume();
        if (OrientationManager.isSupported()) {
            OrientationManager.startListening(this);
        }
    }
 
    protected void onDestroy() {
        super.onDestroy();
        if (OrientationManager.isListening()) {
            OrientationManager.stopListening();
        }
 
    }
 
    public static Context getContext() {
        return CONTEXT;
    }
 
    @Override
    public void onOrientationChanged(float azimuth, 
            float pitch, float roll) {
        ((TextView) findViewById(R.id.azimuth)).setText(
                String.valueOf(azimuth));
        ((TextView) findViewById(R.id.pitch)).setText(
                String.valueOf(pitch));
        ((TextView) findViewById(R.id.roll)).setText(
                String.valueOf(roll));
    }
 
    @Override
    public void onBottomUp() {
        Toast.makeText(this, "Bottom UP", 1000).show();
    }
 
    @Override
    public void onLeftUp() {
        Toast.makeText(this, "Left UP", 1000).show();
    }
 
    @Override
    public void onRightUp() {
        Toast.makeText(this, "Right UP", 1000).show();
    }
 
    @Override
    public void onTopUp() {
        Toast.makeText(this, "Top UP", 1000).show();
    }
 
}

/// <summary>
 
/// Application main class.
 
/// </summary>
 
public class Test
{
    private WavIn m_pSoundReceiver = null;
 
    /// <summary>
 
    /// Default constructor.
 
    /// </summary>
 
    public Test()
    {
        // G711 needs 8KHZ 16 bit 1 channel audio, 
 
        // 400kb buffer gives us 25ms audio frame.
 
        m_pSoundReceiver = new WavIn(WavIn.Devices[0],8000,16,1,400);
        m_pSoundReceiver.BufferFull += new BufferFullHandler 
                                         (m_pSoundReceiver_BufferFull);
        m_pSoundReceiver.Start();
    }
 
    /// <summary>
 
    /// This method is called when recording buffer is full 
 
    /// and we need to process it.
 
    /// </summary>
 
    /// <param name="buffer">Recorded data.</param>
 
    private void m_pSoundReceiver_BufferFull(byte[] buffer)
    {
        // Just store audio data or stream it over the network ... 
 
    }
}

public class WindowsUISettings
{
    // Khai báo sử dụng API SystemParametersInfo
    [DllImport("user32.dll", CharSet = CharSet.Auto)]
    private static extern bool SystemParametersInfo(
        int Action, int uiParam, [In, Out] NONCLIENTMETRICS pvParam, int WinIni);
 
    [StructLayout(LayoutKind.Sequential)]
    private class NONCLIENTMETRICS
    {
        public int cbSize = Marshal.SizeOf(typeof(NONCLIENTMETRICS));
        public int iBorderWidth;
        public int iScrollWidth;
        public int iScrollHeight;
        public int iCaptionWidth;
        public int iCaptionHeight;
        [MarshalAs(UnmanagedType.Struct)]
        public LOGFONT lfCaptionFont;
        public int iSmCaptionWidth;
        public int iSmCaptionHeight;
        [MarshalAs(UnmanagedType.Struct)]
        public LOGFONT lfSmCaptionFont;
        public int iMenuWidth;
        public int iMenuHeight;
        [MarshalAs(UnmanagedType.Struct)]
        public LOGFONT lfMenuFont;
        [MarshalAs(UnmanagedType.Struct)]
        public LOGFONT lfStatusFont;
        [MarshalAs(UnmanagedType.Struct)]
        public LOGFONT lfMessageFont;
    }
 
 
    private const int LF_FACESIZE = 32;
 
    // A "logical font" used by old-school windows
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
    private class LOGFONT
    {
        public int lfHeight;
        public int lfWidth;
        public int lfEscapement;
        public int lfOrientation;
        public int lfWeight;
        public byte lfItalic;
        public byte lfUnderline;
        public byte lfStrikeOut;
        public byte lfCharSet;
        public byte lfOutPrecision;
        public byte lfClipPrecision;
        public byte lfQuality;
        public byte lfPitchAndFamily;
 
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = LF_FACESIZE)]
        public string lfFaceName;
 
        // to shut it up about the warnings
        public LOGFONT(string lfFaceName)
        {
            this.lfFaceName = lfFaceName;
            lfHeight = lfWidth = lfEscapement = lfOrientation = lfWeight = 0;
            lfItalic = lfUnderline = lfStrikeOut = lfCharSet = lfOutPrecision
            = lfClipPrecision = lfQuality = lfPitchAndFamily = 0;
        }
    }
 
    //Khai báo SPI lấy và thay đổi thiết lập về
    //caption, menu, status bar, scroll bar và message box
    private const int SPI_GETNONCLIENTMETRICS = 0x0029;
    private const int SPI_SETNONCLIENTMETRICS = 0x002A;
 
    private NONCLIENTMETRICS currentMetrics;
 
    /// <summary>
    /// Lưu giữ lại các giá trị ngầm định
    /// </summary>
    private static NONCLIENTMETRICS defaultMetrics;
 
    private WindowsUISettings()
    { }
 
    public static WindowsUISettings CurrentMetrics()
    {
        //Lưu giữ lại các giá trị ngầm định
        defaultMetrics = new NONCLIENTMETRICS();
        SystemParametersInfo(SPI_GETNONCLIENTMETRICS, defaultMetrics.cbSize, defaultMetrics, 0);
 
        NONCLIENTMETRICS pvParam = new NONCLIENTMETRICS();
        SystemParametersInfo(SPI_GETNONCLIENTMETRICS, pvParam.cbSize, pvParam, 0);
 
        WindowsUISettings instance = new WindowsUISettings();
        instance.currentMetrics = pvParam;
 
        return instance;
    }
 
    /// <summary>
    /// Lấy/Thiết lập font chữ cho MessageBox
    /// </summary>
    public Font MessageFont
    {
        get
        {
            return Font.FromLogFont(currentMetrics.lfMessageFont);
        }
        set
        {
            value.ToLogFont(currentMetrics.lfMessageFont);
        }
    }
 
    /// <summary>
    /// Thiết lập các thay đổi
    /// </summary>
    public void Apply()
    {
        SystemParametersInfo(SPI_SETNONCLIENTMETRICS, currentMetrics.cbSize, currentMetrics, 1);
    }
 
    /// <summary>
    /// Đặt lại các giá trị ngầm định
    /// </summary>
    public void RestoreDefault()
    {
        SystemParametersInfo(SPI_SETNONCLIENTMETRICS, defaultMetrics.cbSize, defaultMetrics, 1);
    }
}

public partial class Form1 : Form
{
    WindowsUISettings metrics
        = WindowsUISettings.CurrentMetrics();
 
    public Form1()
    {
        InitializeComponent();
    }
 
    private void button1_Click(object sender, EventArgs e)
    {
        Font messageFont = new Font(
            metrics.MessageFont.FontFamily, 14);
 
        metrics.MessageFont = messageFont;
        metrics.Apply();
 
        MessageBox.Show(
        "MessageBox đã được thay đổi font size thành 14.");
    }
 
    private void button2_Click(object sender, EventArgs e)
    {
        metrics.RestoreDefault();
        MessageBox.Show(
        "MessageBox đã được trở về font size 8.");
 
    }
}