Xamarin.Forms
निर्भरता सेवा के साथ देशी सुविधाओं तक पहुँचना

टिप्पणियों

var speaker = DependencyService.Get<ITextToSpeech>();

if (speaker != null)
{
    speaker.Speak("Ready for action!");
}

var speaker = DependencyService.Get<ITextToSpeech>();

speaker?.Speak("Ready for action!");

पाठ-से-भाषण को लागू करना

प्लेटफ़ॉर्म विशिष्ट कोड का अनुरोध करने वाली सुविधा का एक अच्छा उदाहरण वह है जब आप टेक्स्ट-टू-स्पीच (टीटीएस) को लागू करना चाहते हैं। यह उदाहरण मानता है कि आप PCL लाइब्रेरी में साझा कोड के साथ काम कर रहे हैं।

हमारे समाधान का एक योजनाबद्ध अवलोकन नीचे की छवि जैसा दिखेगा।

हमारे साझा कोड में हम एक इंटरफ़ेस परिभाषित करते हैं जो DependencyService साथ पंजीकृत होता है। यह वह जगह है जहां हम अपने कॉल करेंगे। नीचे की तरह एक इंटरफ़ेस परिभाषित करें।

public interface ITextToSpeech
{
    void Speak (string text);
}

अब प्रत्येक विशिष्ट मंच में, हमें इस इंटरफ़ेस का कार्यान्वयन बनाने की आवश्यकता है। आइए आईओएस कार्यान्वयन के साथ शुरू करें।

आईओएस कार्यान्वयन

using AVFoundation;

public class TextToSpeechImplementation : ITextToSpeech
{
    public TextToSpeechImplementation () {}

    public void Speak (string text)
    {
        var speechSynthesizer = new AVSpeechSynthesizer ();

        var speechUtterance = new AVSpeechUtterance (text) {
            Rate = AVSpeechUtterance.MaximumSpeechRate/4,
            Voice = AVSpeechSynthesisVoice.FromLanguage ("en-US"),
            Volume = 0.5f,
            PitchMultiplier = 1.0f
        };

        speechSynthesizer.SpeakUtterance (speechUtterance);
    }
}

ऊपर दिए गए कोड उदाहरण में आप देखते हैं कि iOS के लिए विशिष्ट कोड है। AVSpeechSynthesizer जैसे प्रकार। ये साझा कोड में काम नहीं करेंगे।

Xamarin DependencyService साथ इस कार्यान्वयन को पंजीकृत करने के लिए नामस्थान घोषणा के ऊपर यह विशेषता जोड़ें।

using AVFoundation;
using DependencyServiceSample.iOS;//enables registration outside of namespace

[assembly: Xamarin.Forms.Dependency (typeof (TextToSpeechImplementation))]
namespace DependencyServiceSample.iOS {
    public class TextToSpeechImplementation : ITextToSpeech
//... Rest of code

अब जब आप अपने साझा कोड में इस तरह की कॉल करते हैं, तो जिस प्लेटफ़ॉर्म पर आप अपना ऐप चला रहे हैं, उसके लिए सही कार्यान्वयन इंजेक्ट किया जाता है।

DependencyService.Get<ITextToSpeech>() । इस पर और बाद में।

Android कार्यान्वयन

इस कोड का Android कार्यान्वयन नीचे की तरह दिखेगा।

using Android.Speech.Tts;
using Xamarin.Forms;
using System.Collections.Generic;
using DependencyServiceSample.Droid;

public class TextToSpeechImplementation : Java.Lang.Object, ITextToSpeech, TextToSpeech.IOnInitListener
{
    TextToSpeech speaker;
    string toSpeak;

    public TextToSpeechImplementation () {}

    public void Speak (string text)
    {
        var ctx = Forms.Context; // useful for many Android SDK features
        toSpeak = text;
        if (speaker == null) {
            speaker = new TextToSpeech (ctx, this);
        } else {
            var p = new Dictionary<string,string> ();
            speaker.Speak (toSpeak, QueueMode.Flush, p);
        }
    }

    #region IOnInitListener implementation
    public void OnInit (OperationResult status)
    {
        if (status.Equals (OperationResult.Success)) {
            var p = new Dictionary<string,string> ();
            speaker.Speak (toSpeak, QueueMode.Flush, p);
        }
    }
    #endregion
}

फिर से यह DependencyService साथ रजिस्टर करने के लिए मत भूलना।

using Android.Speech.Tts;
using Xamarin.Forms;
using System.Collections.Generic;
using DependencyServiceSample.Droid;


[assembly: Xamarin.Forms.Dependency (typeof (TextToSpeechImplementation))]
namespace DependencyServiceSample.Droid{
    //... Rest of code

विंडोज फोन कार्यान्वयन

अंत में, विंडोज फोन के लिए इस कोड का उपयोग किया जा सकता है।

public class TextToSpeechImplementation : ITextToSpeech
{
    public TextToSpeechImplementation() {}

    public async void Speak(string text)
    {
        MediaElement mediaElement = new MediaElement();

        var synth = new Windows.Media.SpeechSynthesis.SpeechSynthesizer();

        SpeechSynthesisStream stream = await synth.SynthesizeTextToStreamAsync("Hello World");

        mediaElement.SetSource(stream, stream.ContentType);
        mediaElement.Play();
        await synth.SynthesizeTextToStreamAsync(text);
    }
}

और एक बार और इसे रजिस्टर करना न भूलें।

using Windows.Media.SpeechSynthesis;
using Windows.UI.Xaml.Controls;
using DependencyServiceSample.WinPhone;//enables registration outside of namespace

[assembly: Xamarin.Forms.Dependency (typeof (TextToSpeechImplementation))]
namespace DependencyServiceSample.WinPhone{
    //... Rest of code

साझा कोड में लागू करना

अब यह काम करने के लिए सब कुछ है! अंत में, अपने साझा कोड में अब आप इंटरफ़ेस का उपयोग करके इस फ़ंक्शन को कॉल कर सकते हैं। रनटाइम के दौरान, कार्यान्वयन को इंजेक्ट किया जाएगा जो उस चालू प्लेटफॉर्म से मेल खाती है जिस पर वह चल रहा है।

इस कोड में आपको एक पेज दिखाई देगा जो Xamarin Forms प्रोजेक्ट में हो सकता है। यह एक बटन बनाता है जो DependencyService का उपयोग करके Speak() विधि को आमंत्रित करता है।

public MainPage ()
{
    var speak = new Button {
        Text = "Hello, Forms !",
        VerticalOptions = LayoutOptions.CenterAndExpand,
        HorizontalOptions = LayoutOptions.CenterAndExpand,
    };
    speak.Clicked += (sender, e) => {
        DependencyService.Get<ITextToSpeech>().Speak("Hello from Xamarin Forms");
    };
    Content = speak;
}

इसका परिणाम यह होगा कि जब ऐप चलाया जाता है और बटन पर क्लिक किया जाता है, तो प्रदान किया गया टेक्स्ट बोला जाएगा।

यह सब संकलक संकेत और जैसे कठिन सामान करने के लिए बिना। अब आपके पास प्लेटफ़ॉर्म स्वतंत्र कोड के माध्यम से प्लेटफ़ॉर्म विशिष्ट कार्यक्षमता तक पहुंचने का एक समान तरीका है।

एप्लिकेशन और डिवाइस OS संस्करण नंबर प्राप्त करना - Android और iOS - PCL

नीचे दिए गए उदाहरण डिवाइस के ओएस संस्करण संख्या और है कि Android और संस्करण iOS पर पर संस्करण नाम में प्रवेश आवेदन (जो एक परियोजनाओं 'गुण में परिभाषित किया गया है) के संस्करण एकत्रित करेगा।

पहले अपने PCL प्रोजेक्ट में एक इंटरफ़ेस बनाएँ:

public interface INativeHelper {
    /// <summary>
    /// On iOS, gets the <c>CFBundleVersion</c> number and on Android, gets the <c>PackageInfo</c>'s <c>VersionName</c>, both of which are specified in their respective project properties.
    /// </summary>
    /// <returns><c>string</c>, containing the build number.</returns>
    string GetAppVersion();

    /// <summary>
    /// On iOS, gets the <c>UIDevice.CurrentDevice.SystemVersion</c> number and on Android, gets the <c>Build.VERSION.Release</c>.
    /// </summary>
    /// <returns><c>string</c>, containing the OS version number.</returns>
    string GetOsVersion();
}

अब हम एंड्रॉइड और आईओएस परियोजनाओं में इंटरफ़ेस को लागू करते हैं।

एंड्रॉयड:

[assembly: Dependency(typeof(NativeHelper_Android))]

namespace YourNamespace.Droid{
    public class NativeHelper_Android : INativeHelper {
        
        /// <summary>
        /// See interface summary.
        /// </summary>
        public string GetAppVersion() {
            Context context = Forms.Context;
            return context.PackageManager.GetPackageInfo(context.PackageName, 0).VersionName;
        }

        /// <summary>
        /// See interface summary.
        /// </summary>
        public string GetOsVersion() { return Build.VERSION.Release; }
    }
}

iOS:

[assembly: Dependency(typeof(NativeHelper_iOS))]

namespace YourNamespace.iOS {
    public class NativeHelper_iOS : INativeHelper {
        
        /// <summary>
        /// See interface summary.
        /// </summary>
        public string GetAppVersion() { return Foundation.NSBundle.MainBundle.InfoDictionary[new Foundation.NSString("CFBundleVersion")].ToString(); }

        /// <summary>
        /// See interface summary.
        /// </summary>
        public string GetOsVersion() { return UIDevice.CurrentDevice.SystemVersion; }
    }
}

अब एक विधि में कोड का उपयोग करने के लिए:

public string GetOsAndAppVersion {
    INativeHelper helper = DependencyService.Get<INativeHelper>();

    if(helper != null) {
        string osVersion  = helper.GetOsVersion();
        string appVersion = helper.GetBuildNumber()
    }
}