MSDN Documentation

Accessing Device Features with Xamarin

Xamarin allows you to tap into the rich set of device-specific features available on iOS, Android, and Windows devices. This guide explores common device features and how to access them using Xamarin.Forms and native Xamarin development.

Why Access Device Features?

Leveraging device features enhances the user experience by making your application more context-aware and interactive. This can include:

• Location Services: Getting the user's current location.
• Camera: Taking photos or recording videos.
• Accelerometer/Gyroscope: Detecting device motion and orientation.
• Contacts: Accessing the user's contact list.
• Storage: Reading and writing files to local storage.
• Sensors: Utilizing various device sensors like proximity or light sensors.

Common Device Features and Xamarin Implementations

1. Location Services

Accessing location data is crucial for many applications, from navigation to location-aware services. Xamarin.Essentials provides a cross-platform API for this.

using Xamarin.Essentials;
using System;
using System.Threading.Tasks;

public class LocationService
{
    public async Task GetCurrentLocationAsync()
    {
        try
        {
            var location = await Geolocation.GetLastKnownLocationAsync();
            if (location == null)
            {
                location = await Geolocation.GetLocationAsync(new GeolocationRequest(GeolocationAccuracy.High));
            }

            if (location != null)
            {
                Console.WriteLine($"Latitude: {location.Latitude}, Longitude: {location.Longitude}, Altitude: {location.Altitude}");
            }
        }
        catch (FeatureNotSupportedException fnsEx)
        {
            // Location is not supported on this device
            Console.WriteLine($"Location not supported: {fnsEx.Message}");
        }
        catch (PermissionException pEx)
        {
            // Handle permission issues
            Console.WriteLine($"Permission denied: {pEx.Message}");
        }
        catch (Exception ex)
        {
            // Unable to get location
            Console.WriteLine($"Error getting location: {ex.Message}");
        }
    }
}

Remember to request the necessary permissions in your platform-specific manifest files (e.g., AndroidManifest.xml for Android, Info.plist for iOS).

2. Camera

Integrating the camera allows users to capture images or videos within your app. Xamarin.Essentials simplifies this with the MediaPicker class.

using Xamarin.Essentials;
using System;
using System.IO;
using System.Threading.Tasks;

public class CameraService
{
    public async Task TakePhotoAsync()
    {
        try
        {
            var photo = await MediaPicker.CapturePhotoAsync();

            // canceled
            if (photo == null)
            {
                return;
            }

            // save photo
            var newFile = Path.Combine(FileSystem.CacheDirectory, photo.FileName);
            using (var stream = await photo.OpenReadAsync())
            using (var newStream = File.OpenWrite(newFile))
            {
                await stream.CopyToAsync(newStream);
            }

            Console.WriteLine($"Photo saved to: {newFile}");
        }
        catch (FeatureNotSupportedException fnsEx)
        {
            // Feature is not supported on the device
            Console.WriteLine($"Camera not supported: {fnsEx.Message}");
        }
        catch (PermissionException pEx)
        {
            // Handle permission issues
            Console.WriteLine($"Permission denied: {pEx.Message}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error capturing photo: {ex.Message}");
        }
    }
}

3. Accelerometer and Gyroscope

These sensors provide data about device motion and orientation. Xamarin.Essentials' Accelerometer and Gyroscope classes offer easy access.

using Xamarin.Essentials;
using System;

public class MotionService
{
    public void StartListeningToMotion()
    {
        // Register for reading accelerometer data
        Accelerometer.ReadingChanged += Accelerometer_ReadingChanged;
        Accelerometer.StartListening();

        // Register for reading gyroscope data
        Gyroscope.ReadingChanged += Gyroscope_ReadingChanged;
        Gyroscope.StartListening();
    }

    public void StopListeningToMotion()
    {
        Accelerometer.ReadingChanged -= Accelerometer_ReadingChanged;
        Accelerometer.StopListening();

        Gyroscope.ReadingChanged -= Gyroscope_ReadingChanged;
        Gyroscope.StopListening();
    }

    void Accelerometer_ReadingChanged(object sender, AccelerometerChangedEventArgs e)
    {
        var data = e.Reading;
        Console.WriteLine($"Accelerometer: X={data.Acceleration.X}, Y={data.Acceleration.Y}, Z={data.Acceleration.Z}");
        // Handle accelerometer data
    }

    void Gyroscope_ReadingChanged(object sender, GyroscopeChangedEventArgs e)
    {
        var data = e.Reading;
        Console.WriteLine($"Gyroscope: X={data.AngularVelocity.X}, Y={data.AngularVelocity.Y}, Z={data.AngularVelocity.Z}");
        // Handle gyroscope data
    }
}

4. File System Access

Managing local storage is essential for saving application data, user preferences, or downloaded content. Xamarin.Essentials provides platform-agnostic ways to access special file system directories.

Common directories include:

• FileSystem.AppDataDirectory: For application-specific data.
• FileSystem.CacheDirectory: For temporary cache files.
• FileSystem.PublicDirectory: For files that should be accessible to the user (e.g., documents, photos).

using Xamarin.Essentials;
using System;
using System.IO;

public class FileStorageService
{
    public void SaveAppData(string fileName, string content)
    {
        string filePath = Path.Combine(FileSystem.AppDataDirectory, fileName);
        File.WriteAllText(filePath, content);
        Console.WriteLine($"Data saved to: {filePath}");
    }

    public string ReadAppData(string fileName)
    {
        string filePath = Path.Combine(FileSystem.AppDataDirectory, fileName);
        if (File.Exists(filePath))
        {
            return File.ReadAllText(filePath);
        }
        return null;
    }
}

Conclusion

Xamarin.Essentials offers a powerful and convenient way to access a wide range of device features in a cross-platform manner. By utilizing these APIs, you can build more engaging and feature-rich mobile applications that feel native to each platform.

For more advanced scenarios or platform-specific control, you can always drop down to the native APIs provided by iOS (UIKit, Core Location, AVFoundation) and Android (Android SDK, LocationManager, Camera API).