Listing 9.1: Accessing the mic on iOS

using System;
using MonoTouch.AVFoundation;
using MonoTouch.Foundation;
using MonoTouch.AudioToolbox;
using System.IO;

namespace DeviceAccess
{
  class MicAccess
  {
    public MicAccess()
    {
      _mic = new AVAudioRecorder();
    }

    public void StartRecordingFroMic(string FilePath)
    {
      // set some default values for recording settings
      NSObject[] keys = new NSObject[]
            {
                AVAudioSettings.AVSampleRateKey,
                AVAudioSettings.AVFormatIDKey,
                AVAudioSettings.AVNumberOfChannelsKey,
                AVAudioSettings.AVEncoderAudioQualityKey,
            };
      NSObject[] values = new NSObject[]
            {    
                NSNumber.FromFloat(44100.0f),
                NSNumber.FromInt32((int)AudioFileType.WAVE),
                NSNumber.FromInt32(1),
                NSNumber.FromInt32((int)AVAudioQuality.Max),
            };
      NSDictionary settings = NSDictionary.FromObjectsAndKeys(values, keys);

      // define a filename and location for the output file
      string fileName = FilePath;
      string path = 
        Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Personal), fileName);
      outputFileUrl = NSUrl.FromFilename(path);

      // pass the configured url to the AVAudioRecorder object 
      NSError error = new NSError();
      _mic = AVAudioRecorder.ToUrl(outputFileUrl, settings, out error);

      if (error != null)
      {
        // prepare and start recording
        _mic.PrepareToRecord();
        _mic.Record();
      }
      else
      {
        throw new Exception("Error loading mic: " + error.ToString());
      }
    }

    public void StopRecording()
    {
      _mic.Stop();

      // prepare object for GC by calling dispose
      _mic.FinishedRecording += delegate
      {
        _mic.Dispose();
        _mic = null;
      };
    }

    AVAudioRecorder _mic;
    private NSUrl outputFileUrl;
  }
}

Listing 9.2: Accessing the mic on Android

using Android.Media;

namespace DeviceAccess
{
  class MicAccess
  {
    public void StartRecordingFroMic(string FileName)
    {
      // set some default values for recording settings
      _mic.SetAudioSource(AudioSource.Mic);
      _mic.SetOutputFormat(OutputFormat.Default);
      _mic.SetAudioEncoder(AudioEncoder.Default);

      // define a filename and location for the output file
      _mic.SetOutputFile(FileName);

      // prepare and start recording
      _mic.Prepare();
      _mic.Start();
    }

    public void StopRecording()
    {
      // stop recording
      _mic.Stop();

      // prepare object for GC by calling dispose
      _mic.Release();
      _mic = null;
    }

    public MicAccess()
    {
      _mic = new MediaRecorder();
    }
    MediaRecorder _mic;
  }
}

Listing 9.3: Accessing the mic on Windows Phone 7

using System;
using System.IO;
using Microsoft.Xna.Framework.Audio;

namespace DeviceAccess
{
  public class MicAccess
  {
    public void StartRecordingFroMic(string FilePath)
    {
      // close memory steam if left open
      if (_memoryStream != null)
      {
        _memoryStream.Close();
      }

      // start a new memory stream
      _memoryStream = new MemoryStream();

      // start recording
      _mic.Start();
    }

    public void StopRecording()
    {
      // stop recording
      if (_mic.State != MicrophoneState.Stopped)
      {
        _mic.Stop();
      }

      // reset memory buffer
      _memoryStream.Position = 0;
    }

    void ProcessingBuffer(object sender, EventArgs e)
    {

      // read in read values
      byte[] buffer = new byte[4096];
      int bytesRead = _mic.GetData(buffer, 0, buffer.Length);

      // write and read mic buffer contents
      while (bytesRead > 0)
      {
        _memoryStream.Write(buffer, 0, bytesRead);
        bytesRead = _mic.GetData(buffer, 0, buffer.Length);
      }
    }

    public MicAccess()
    {
      _mic.BufferReady += ProcessingBuffer;
    }
    MemoryStream _memoryStream;
    Microphone _mic = Microphone.Default;
  }
}

Listing 9.4: Playing audio on iOS

using System;
using MonoTouch.Foundation;
using MonoTouch.AVFoundation;

namespace DeviceAccess
{
  public class AudioAccess
  {
    public void StartAudioPlayback(string AudioFilePath)
    {
      NSError error = null;
      NSUrl audioFileUrl = NSUrl.FromFilename(AudioFilePath);
      _player = AVAudioPlayer.FromUrl(audioFileUrl, out error);
      if (_player != null)
      {
        _player.PrepareToPlay();
        _player.Play();
      }
      else
      {
        throw new Exception("Could not load Accelerometer sensor");
      }
    }

    public void StopAudioPlayback()
    {
      if (_player != null)
      {
        _player.Stop();
        _player.Dispose();
        _player = null;
      }
    }

    AVAudioPlayer Player
    {
      get
      {
        return _player;
      }
      set
      {
        _player = value;
      }
    }
    AVAudioPlayer _player;
  }
}

Listing 9.5: Playing audio on Android

using System;
using System.IO;
using Android.Media;

namespace DeviceAccess
{
  public class AudioAccess
  {
    public void StartAudioPlayback(string AudioFilePath)
    {
      // first stop any active audio on MediaPlayer instance
      if (_player != null) { StopAudioPlayback(); }

      _player = new MediaPlayer();
      if (_player != null)
      {
        _player.SetDataSource(AudioFilePath);
        _player.Prepare();
        _player.Start();
      }
      else
      {
        throw new Exception("Could not load MediaPlayer");
      }
    }

    public void StopAudioPlayback()
    {
      if (_player != null)
      {
        if (_player.IsPlaying)
        {
          _player.Stop();
        }

        _player.Release();
        _player = null;
      }
    }

    public void MultiMediaPlayer(String path, String fileName)
    {
      //set up MediaPlayer    
      MediaPlayer mp = new MediaPlayer();

      try
      {
        mp.SetDataSource(Path.Combine(path, fileName));
      }
      catch (Exception e)
      {
        Console.WriteLine("");
      }
      try
      {
        mp.Prepare();
      }
      catch (Exception e)
      {
        Console.WriteLine(e);
      }
      mp.Start();
    }

    MediaPlayer _player;
  }
}

Listing 9.6: Playing audio on Windows Phone 7

using System.IO;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;

namespace DeviceAccess
{
  public static class AudioAccess
  {
    public static void StartAudioPlayback(string AudioFilePath)
    {
      Stream stream = TitleContainer.OpenStream(AudioFilePath);
      SoundEffect effect = SoundEffect.FromStream(stream);
      FrameworkDispatcher.Update();
      effect.Play();
    }
  }
}

Listing 9.7: Capturing video on iOS

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MonoTouch.AVFoundation;
using MonoTouch.CoreMedia;
using MonoTouch.UIKit;
using MonoTouch.Foundation;
using MonoTouch.CoreVideo;

namespace DeviceAccess
{
  class VideoRecorder
  {
    public void RecordVideoToPath(UIViewController ViewController, string VideoPath)
    {
      // set up capture device 
      AVCaptureDevice videoRecordingDevice = 
        AVCaptureDevice.DefaultDeviceWithMediaType(AVMediaType.Video);
      NSError error;
      AVCaptureDeviceInput videoInput = new 
        AVCaptureDeviceInput(videoRecordingDevice, out error);

      // create and assign a capture session
      AVCaptureSession captureSession = new AVCaptureSession();
      captureSession.SessionPreset = AVCaptureSession.Preset1280x720;
      captureSession.AddInput(videoInput);

      // Create capture device output
      AVCaptureVideoDataOutput videoOutput = new AVCaptureVideoDataOutput();
      captureSession.AddOutput(videoOutput);
      videoOutput.VideoSettings.PixelFormat = CVPixelFormatType.CV32BGRA;
      videoOutput.MinFrameDuration = new CMTime(1, 30);
      videoOutput.SetSampleBufferDelegatequeue(captureVideoDelegate, 
        System.IntPtr.Zero);

      // create a delegate class for handling capture
      captureVideoDelegate = new CaptureVideoDelegate(ViewController);

      // Start capture session
      captureSession.StartRunning();
    }
    CaptureVideoDelegate captureVideoDelegate;

    public class CaptureVideoDelegate : AVCaptureVideoDataOutputSampleBufferDelegate
    {
      private UIViewController _viewController;

      public CaptureVideoDelegate(UIViewController viewController)
      {
        _viewController = viewController;
      }

      public override void DidOutputSampleBuffer(AVCaptureOutput output, 
        CMSampleBuffer buffer, AVCaptureConnection con)
      {
        //  Implement
        //  - see: http://go-
        //mono.com/docs/index.aspx?link=T%3aMonoTouch.Foundation.ModelAttribute
        //
      }
    }
  }
}

Listing 9.8: Capturing video on Android

using System;
using Android.App;
using Android.OS;
using Android.Views;
using Android.Media;

namespace DeviceAccess
{

  public class RecordVideo
  {
    public void RecordVideoToPath(SurfaceView Sv, string VideoPath)
    {
      // set up and configure recorder
      _mediaRecorder = new MediaRecorder();

      // set the input source
      _mediaRecorder.SetAudioSource(Android.Media.AudioSource.Mic);
      _mediaRecorder.SetVideoSource(Android.Media.VideoSource.Camera);

      // set encoding values 
      _mediaRecorder.SetAudioEncoder(Android.Media.AudioEncoder.Default);
      _mediaRecorder.SetVideoEncoder(Android.Media.VideoEncoder.Default);

      // set the desirable preview display 
      _mediaRecorder.SetPreviewDisplay(Sv.Holder.Surface);

      // set output file locationa and format
      _mediaRecorder.SetOutputFormat(Android.Media.OutputFormat.Default);
      _mediaRecorder.SetOutputFile(VideoPath);

      _mediaRecorder.Prepare();

    }

    public void StopRecording()
    {
      if (_mediaRecorder != null)
      {
        _mediaRecorder.Stop();
        _mediaRecorder.Release();
        _mediaRecorder = null;
      }
    }

    MediaRecorder _mediaRecorder;
  }}

Listing 9.9: Capturing video on Windows Phone 7

using System;
using System.Windows;
using System.Windows.Media;
using System.Windows.Shapes;
using System.IO.IsolatedStorage;

namespace DeviceAccess
{
  public class VideoAccess
  {
    // Source and device for capturing video.
    CaptureSource captureSource;
    VideoCaptureDevice videoCaptureDevice;

    // File details for storing the recording.        
    IsolatedStorageFileStream isoVideoFile;
    FileSink fileSink;

    // Viewfinder for capturing video.
    VideoBrush videoRecorderBrush;

    public void StartRecording(Rectangle viewfinderRectangle, string filePath)
    {
      InitializeVideoRecorder(viewfinderRectangle);

      // Connect fileSink to captureSource.
      if (captureSource.VideoCaptureDevice != null
          && captureSource.State == CaptureState.Started)
      {
        captureSource.Stop();

        // Connect the input and output of fileSink.
        fileSink.CaptureSource = captureSource;
        fileSink.IsolatedStorageFileName = filePath;
      }

      // Begin recording.
      if (captureSource.VideoCaptureDevice != null
          && captureSource.State == CaptureState.Stopped)
      {
        captureSource.Start();
      }
    }

    public void StopRecording()
    {
      if (captureSource != null)
      {
        // Stop captureSource if it is running.
        if (captureSource.VideoCaptureDevice != null
            && captureSource.State == CaptureState.Started)
        {
          captureSource.Stop();
        }

        // Remove the event handlers for captureSource and the shutter button.
        captureSource.CaptureFailed -= OnCaptureFailed;

        // Remove the video recording objects.
        captureSource = null;
        videoCaptureDevice = null;
        fileSink = null;
        videoRecorderBrush = null;
      }
    }

    void InitializeVideoRecorder(Rectangle viewfinderRectangle)
    {
      if (captureSource == null)
      {
        // Create the VideoRecorder objects.
        captureSource = new CaptureSource();
        fileSink = new FileSink();

        videoCaptureDevice = CaptureDeviceConfiguration.GetDefaultVideoCaptureDevice();

        // Add eventhandlers for captureSource.
        captureSource.CaptureFailed += new 
EventHandler<ExceptionRoutedEventArgs>(OnCaptureFailed);

        // Initialize the camera if it exists on the device.
        if (videoCaptureDevice != null)
        {
          // Create the VideoBrush for the viewfinder.
          videoRecorderBrush = new VideoBrush();
          videoRecorderBrush.SetSource(captureSource);

          // Display the viewfinder image on the rectangle.
          viewfinderRectangle.Fill = videoRecorderBrush;

          // Start video capture and display it on the viewfinder.
          captureSource.Start();
        }
        else
        {
          // A camera is not supported on this device
        }
      }
    }

    void OnCaptureFailed(object sender, ExceptionRoutedEventArgs e)
    {
    }
  }
}
}

using MonoTouch.MediaPlayer;

var videoPlayer = new MPMoviePlayerController(new NSUrl("myVideo.m4v"));
videoPlayer.Play ();

Listing 9.10: Playing video on Android

using Android.Views;
using Android.Media;

namespace DeviceAccess
{
  class VideoPlayer
  {
    public void StartVideoPlayback(SurfaceView surface, string FilePath)
    {
      if (_player != null)
      {
        StopVideoPlayback();
      }
      _player = new MediaPlayer();

      ISurfaceHolder holder = surface.Holder;
      holder.SetType(Android.Views.SurfaceType.PushBuffers);
      holder.SetFixedSize(400, 300);

      _player.SetDisplay(holder);
      _player.SetDataSource(FilePath);
      _player.Prepare();
      _player.Start();
    }

    public void StopVideoPlayback()
    {
      if (_player != null)
      {
        if (_player.IsPlaying)
        {
          _player.Stop();
        }

        _player.Release();
        _player = null;
      }
    }
    MediaPlayer _player;
  }
}

Listing 9.11: Playing video on Windows Phone 7

using System;
using Microsoft.Phone.Tasks;

namespace DeviceAccess
{
  public class VideoPlayer
  {
    public void StartAudioPlayback(string AudioFilePath)
    {
      MediaPlayerLauncher objMediaPlayerLauncher = new MediaPlayerLauncher();
      objMediaPlayerLauncher.Media = new Uri(AudioFilePath, UriKind.Relative);
      objMediaPlayerLauncher.Location = MediaLocationType.Install;
      objMediaPlayerLauncher.Controls = MediaPlaybackControls.Pause | 
        MediaPlaybackControls.Stop | MediaPlaybackControls.All;
      objMediaPlayerLauncher.Orientation = MediaPlayerOrientation.Landscape;
      objMediaPlayerLauncher.Show();
    }
  }
}

ABAddressBook iPhoneAddressBook = new ABAddressBook();
ABPerson[] Contacts = iPhoneAddressBook.GetPeople();

foreach (ABPerson item in Contacts)
{
    ABMultiValue<NSDictionary> Contact  = item.GetPhones();
    foreach (ABMultiValueEntry<NSDictionary> cont in Contact)
    {
        // a label containing text describing the number
        // the phone number value

    }
}

<uses-permission android:name="android.permission.READ_CONTACTS" />

Listing 9.12: Looking up contacts on Android

using System;
using Android.App;
using Android.Content;
using Android.Provider;
using Android.Database;

namespace DeviceAccess
{
  class ContactsAccess : Activity
  {
    public IntPtr LookupContactByName(string name, ContentResolver cr)
    {
      IntPtr handle = IntPtr.Zero;

      ICursor cur = cr.Query(ContactsContract.Contacts.ContentUri,
                                          null, null, null, null);
      if (cur.Count > 0)
      {
        while (cur.MoveToNext())
        {
          int lookupColumn = 
            cur.GetColumnIndex(ContactsContract.ContactsColumnsConsts.LookupKey);
          int columnIndex = cur.GetColumnIndex(lookupColumn.ToString());
          String id = cur.GetString(columnIndex);

          string displayNameColumn = 
            ContactsContract.ContactsColumnsConsts.DisplayName.ToString();
          string displayNameColumnIndex = 
            cur.GetColumnIndex(displayNameColumn).ToString();
          String displayName = 
            cur.GetString(cur.GetColumnIndex(displayNameColumnIndex));
          if (displayName.Contains(name))
          {

            handle = cur.Handle;
          }
        }
      }
      return handle;
    }
  }
}

Listing 9.13: Looking up contacts on Windows Phone 7

using System;
using Microsoft.Phone.UserData;
using System.Collections.Generic;
using System.Threading;

namespace DeviceAccess
{
  public class ContactsAccess
  {
    public List<string> LookupContactName(string Name)
    {
      // create a contact object and it's search handler
      Contacts cons = new Contacts();
      cons.SearchCompleted += new 
            EventHandler<ContactsSearchEventArgs>(Contacts_SearchCompleted);

      // start the search
      cons.SearchAsync(Name, FilterKind.None, string.Empty);

      // block on the search until the async result return
      List<string> results;
      lock (_locker)
      {
        while (name == null)
        {
          Monitor.Pulse(_locker);
        }

        results = name;
        name = null;
      }
      return results;
    }
    static readonly object _locker = new object();
    List<string> name = null;

    void Contacts_SearchCompleted(object sender, ContactsSearchEventArgs e)
    {
      lock (_locker)
      {
        // reset list
        name = new List<string>();

        // build new result list
        if (e.Results != null)
        {
          var en = e.Results.GetEnumerator();
          while (en.MoveNext())
          {
            name.Add(en.Current.DisplayName);
          }
        }
        Monitor.Pulse(_locker);
      }
    }
  }
}

Listing 9.14: Initiating a phone call on cell-enabled iOS devices

using MonoTouch.Foundation;
using MonoTouch.UIKit;

namespace DeviceAccess
{
  class PhoneAccess
  {
    public bool DialNumber(string PhoneNumber, bool DisplayWarning)
    {
      bool successfulDialing = false;

      // Kick off dialing using iOS's deep linking
      NSUrl url = new NSUrl("tel:" + PhoneNumber);
      if (UIApplication.SharedApplication.OpenUrl(url))
      {
        successfulDialing = true;
      }
      else if (DisplayWarning)
      {
        UIAlertView av =
            new UIAlertView("Dialing Failed", "Dialing not supported", 
              null, "OK", null);
        av.Show();
      }

      return successfulDialing;
    }
  }
}

string uri = string.Format("tel:{0}", "612-555-1212");
Android.Net.Uri phoneNumber = Android.Net.Uri.Parse(uri);
StartActivity(new Intent(Intent.ActionDial, phoneNumber));

Listing 9.15: Initiating a phone call on Windows Phone 7 devices

using Microsoft.Phone.Tasks;

namespace DeviceAccess
{
  class PhoneAccess
  {
    public void DialNumber(string PhoneNumber)
    {
      PhoneCallTask task = new PhoneCallTask();
      task.PhoneNumber = "651-555-1212";
      task.Show();
    }
  }
}

Listing 9.16: Getting location information on an iOS device

using System.Threading;
using MonoTouch.CoreLocation;

namespace DeviceAccess
{
  public class GpsAccess
  {
    public string ReturnHeading()
    {
      if (_lm != null)
      {
        _lm = new CLLocationManager();
        _lm.UpdatedHeading += HeadingUpdateDelegate;
        _lm.StartUpdatingHeading();
      }

      // block on the search until the async result return
      string result;
      lock (_locker)
      {
        while (location == null)
        {
          Monitor.Pulse(_locker);
        }

        result = location;
        location = null;
      }
      return result;
    }

    void CompassCancel()
    {
      if (_lm != null)
      {
        _lm.StopUpdatingHeading();
        _lm.Dispose();
        _lm = null;
      }
    }
    static CLLocationManager _lm;

    private void HeadingUpdateDelegate(object sender, CLHeadingUpdatedEventArgs e)
    {
      lock (_locker)
      {
        // build new result list
        if (_lm != null && _lm.Heading != null)
        {
          location = _lm.Heading.MagneticHeading.ToString();
        }
        Monitor.Pulse(_locker);
      }
    }
    static readonly object _locker = new object();
    string location = null;
  }
}

Listing 9.17: Getting location information on an Android device

using System;
using System.Threading;
using Android.Content;
using Android.Hardware;

namespace DeviceAccess
{
  public class CompassSensor : ISensorEventListener
  {
    protected string ReturnHeading()
    {
      SensorManager sm = _context.GetSystemService(Context.SensorService) 
        as SensorManager;

      Sensor sensor = sm.GetDefaultSensor(SensorType.Orientation);
      if (sensor != null)
      {
        sm.RegisterListener(this, sensor, SensorDelay.Ui);
      }

      // block on the search until the async result return
      string heading;
      lock (_locker)
      {
        while (location == null)
        {
          Monitor.Pulse(_locker);
        }

        heading = location;
        location = null;
      }
      return heading;
    }

    protected void CompassCancel()
    {
      SensorManager sm = _context.GetSystemService(Context.SensorService) 
        as SensorManager;
      Sensor sensor = sm.GetDefaultSensor(SensorType.Orientation);
      sm.UnregisterListener(this, sensor);
    }

    public void OnSensorChanged(SensorEvent e)
    {
      if (e.Sensor.Type == SensorType.Proximity)
      {
        lock (_locker)
        {

          location = e.ToString();
          Monitor.Pulse(_locker);
        }
      }
    }
    static readonly object _locker = new object();
    string location = null;

    Context _context;

    public void OnAccuracyChanged(Sensor sensor, int accuracy)
    {
      return;
    }

    public IntPtr Handle
    {
      get { throw new NotImplementedException(); }
    }
  }
}

Listing 9.18: Getting location information on a Windows Phone 7 device

using System;
using System.Threading;
using Microsoft.Devices.Sensors;

namespace DeviceAccess
{
  public class GpsAccess
  {
    static Compass _compass;

    public string ReturnHeading()
    {
      if (!Compass.IsSupported)
      {
        throw new Exception("Could not load Compass");
      }
      if (_compass == null)
      {
        _compass = new Compass();
        _compass.TimeBetweenUpdates = TimeSpan.FromMilliseconds(100);
        _compass.CurrentValueChanged += new 
           EventHandler<SensorReadingEventArgs<CompassReading>>(_compass_CurrentValueChanged);
        try
        {
          _compass.Start();
        }
        catch (InvalidOperationException e)
        {
          if (_compass != null)
          {
            _compass.Dispose();
            _compass = null;
          }

          throw new Exception("Could not initiate compass readings", e);
        }
      }

      string trueHeading = null;
      if (_compass != null)
      {
        // block on the search until the async result return
        lock (_locker)
        {
          while (_trueHeading == null)
          {
            Monitor.Pulse(_locker);
          }

          trueHeading = _trueHeading;
          _trueHeading = null;
        }
      }
      return trueHeading;
    }
    static readonly object _locker = new object();
    string _trueHeading = null;

    void _compass_CurrentValueChanged(object sender, 
      SensorReadingEventArgs<CompassReading> e)
    {
      lock (_locker)
      {

        _trueHeading = e.SensorReading.TrueHeading.ToString();
        Monitor.Pulse(_locker);
      }
    }

    void CompassCancel()
    {
      if (_compass != null)
      {
        _compass.Stop();
        _compass.Dispose();
        _compass = null;
      }
    }
  }
}

Listing 9.19: Getting accelerometer information on an iOS device

using MonoTouch.UIKit;
using System.Threading;

namespace DeviceAccess
{
  public class AccelerometerAccess
  {
    public string ReturnXyz()
    {
      if (UIAccelerometer.SharedAccelerometer != null)
      {
        UIAccelerometer.SharedAccelerometer.UpdateInterval = 0.05;
        UIAccelerometer.SharedAccelerometer.Acceleration += XyzUpdateDelegate;
      }

      // block on the search until the async result return
      string result;
      lock (_locker)
      {
        while (_xyz == null)
        {
          Monitor.Pulse(_locker);
        }

        result = _xyz;
        _xyz = null;
      }
      return result;
    }
    static readonly object _locker = new object();
    string _xyz = null;

    private void XyzUpdateDelegate(object sender, UIAccelerometerEventArgs e)
    {
      lock (_locker)
      {
        _xyz =
            string.Format("{0:0.00}, {1:0.00}, {2:0.00})", 
              e.Acceleration.X, e.Acceleration.Y, e.Acceleration.Z);

        Monitor.Pulse(_locker);
      }
    }

    void AccelerometerCancel()
    {
      UIAccelerometer.SharedAccelerometer.UpdateInterval = 0.0;
    }

  }
}

Listing 9.20: Getting accelerometer information on an Android device

using System;
using Android.Content;
using Android.Hardware;

namespace DeviceAccess
{
  class AccelerometerSensor : ISensorEventListener
  {
    Context _context;

    protected void AccelerometerStart()
    {
      SensorManager sm = _context.GetSystemService(Context.SensorService) 
as SensorManager;
      Sensor sensor = sm.GetDefaultSensor(SensorType.Accelerometer);
      if (sensor != null)
      {
        sm.RegisterListener(this, sensor, SensorDelay.Ui);
      }
      else
      {
        throw new Exception("Could not load Accelerometer sensor");
      }
    }

    void AccelerometerCancel()
    {
      SensorManager sm = _context.GetSystemService(Context.SensorService) 
        as SensorManager;
      Sensor sensor = sm.GetDefaultSensor(SensorType.Accelerometer);
      sm.UnregisterListener(this);
    }

    public void OnAccuracyChanged(Sensor sensor, int accuracy)
    {
    }

    public void OnSensorChanged(SensorEvent e)
    {
      string js = string.Empty;
      switch (e.Sensor.Type)
      {
        case SensorType.Accelerometer:
          js = string.Format(
            "javascript:accelerometer.onAccelerometerSuccess({0:0.00})",
              e.Values[0], e.Values[1], e.Values[2]);
          break;
      }
      if (js.Length > 0)
      {

      }
    }

    public IntPtr Handle
    {
      get { throw new NotImplementedException(); }
    }
  }
}

Listing 9.21: Getting accelerometer information on a Windows Phone 7 device

using System;
using System.Threading;
using Microsoft.Devices.Sensors;

namespace DeviceAccess
{
  public class AccelerometerAccess
  {
    Accelerometer _accelerometer = new Accelerometer();

    public string GetAccelerometerXyz()
    {
      if (!Accelerometer.IsSupported)
      {
        throw new Exception("Not supported on this device");
      }
      try
      {
        // Start accelerometer for detecting compass axis
        _accelerometer = new Accelerometer();
        _accelerometer.CurrentValueChanged +=
          new EventHandler<SensorReadingEventArgs<AccelerometerReading>>
                                      (_accelerometer_CurrentValueChanged);
        _accelerometer.Start();
      }
      catch (InvalidOperationException e)
      {
        throw new Exception("Error starting accelerometer", e);
      }

      string xyz = null;
      if (_accelerometer != null)
      {
        // block on the search until the async result return
        lock (_locker)
        {
          while (_xyz == null)
          {
            Monitor.Pulse(_locker);
          }

          xyz = _xyz;
          _xyz = null;
        }

      }
      return xyz;
    }
    static readonly object _locker = new object();
    string _xyz = null;

    private void _accelerometer_CurrentValueChanged(object sender, 
      SensorReadingEventArgs<AccelerometerReading> e)
    {
      lock (_locker)
      {
        _xyz = string.Format("{0:0.00}, {1:0.00}, {2:0.00}", 
                                e.SensorReading.Acceleration.X,
                                 e.SensorReading.Acceleration.Y,
                                  e.SensorReading.Acceleration.Z);
        Monitor.Pulse(_locker);
      }
    }

    public void AccelerometerCancel()
    {
      if (_accelerometer != null)
      {
        _accelerometer.Stop();
        _accelerometer.Dispose();
        _accelerometer = null;
      }
    }
  }
}