Glass Explorer Edition SDK बहिष्कृत है. यह दस्तावेज़ एक ऐतिहासिक संदर्भ के रूप में बना रहता है.

इस पेज का अनुवाद Cloud Translation API से किया गया है.

बोलकर फ़ोन को निर्देश

बोलकर फ़ोन को निर्देश देने से आप हैंड्सफ़्री इंटरफ़ेस बना सकते हैं. Glass में आपको इनपुट के तीन तरीके हैं.

बोलकर दिए जाने वाले मुख्य निर्देशों में होम कार्ड से Glassware शुरू किया जाता है. साथ ही, किसी काम के तहत वॉइस कमांड से किसी गतिविधि को पूरा किया जा सकता है. साथ ही, सिस्टम की बोली पहचानने की सुविधा की मदद से, उपयोगकर्ताओं को बोलकर दिए जाने वाले निर्देश, बोलकर दिए जाते हैं.

बोलकर दिए जाने वाले मुख्य निर्देश

इन बोले गए निर्देशों में होम कार्ड (घड़ी का कार्ड) से Glassware लॉन्च किया जाता है. जब आप किसी मुख्य बोले गए निर्देश की घोषणा करते हैं, तो अगर उपयोगकर्ता होम कार्ड पर टैप करके आपका Glassware शुरू करने का फ़ैसला करते हैं, तो Glass अपने आप फ़ॉलबैक के रूप में टच मेन्यू आइटम बना देता है.

ok Glass ध्वनि मुख्य मेनू में ध्वनि आदेश जोड़ने के लिए:

res/xml/<my_voice_trigger>.xml में बोले गए निर्देश के लिए एक्सएमएल संसाधन बनाएं, जो VoiceTriggers.Command में बताए गए मौजूदा निर्देश में से किसी एक का इस्तेमाल करता हो. उदाहरण के लिए, "दौड़ शुरू करें" का इस्तेमाल इस तरह करें.

ध्यान दें: डेवलपमेंट के मकसद से, सबके लिए मौजूद नहीं दिए गए निर्देशों का इस्तेमाल किया जा सकता है.
```
<?xml version="1.0" encoding="utf-8"?>
<trigger command="START_A_RUN" />
```
एक ऐसा बोले गए निर्देश बनाने के लिए जिसमें उपयोगकर्ता आपकी गतिविधि या सेवा शुरू करने से पहले कोई अतिरिक्त वाक्यांश बोलने का अनुरोध करे, एक input एलिमेंट भी शामिल करें. उदाहरण के लिए, अगर "अपडेट पोस्ट करें" विकल्प चुना जा रहा है, तो हो सकता है कि आप ऐसा करना चाहें.
```
<?xml version="1.0" encoding="utf-8"?>
<trigger command="POST_AN_UPDATE">
    <input prompt="@string/glass_voice_prompt" />
</trigger>
```
अपने Android मेनिफ़ेस्ट में com.google.android.glass.action.VOICE_TRIGGER कार्रवाई का इस्तेमाल करके, इंटेंट फ़िल्टर को रजिस्टर करें. इंटेंट फ़िल्टर आपकी गतिविधि या सेवा को तब शुरू करता है, जब उसे पता चलता है कि आपके बोलकर दिए जाने वाले निर्देश में कुछ बोला जा रहा है.
```
<?xml version="1.0" encoding="utf-8"?>
<application ...>
    <activity | service ...>
        <intent-filter>
            <action android:name=
                    "com.google.android.glass.action.VOICE_TRIGGER" />
        </intent-filter>
        <meta-data android:name="com.google.android.glass.VoiceTrigger"
            android:resource="@xml/my_voice_trigger" />
    </activity | service>
    // ...
</application>
```
अपनी गतिविधि या सेवा के लिए, android:icon एट्रिब्यूट बताएं. इससे Glass, ठीक है, ग्लास टच मेन्यू में आपके Glassware का आइकॉन दिखाता है.
```
<activity |service
    android:icon="@drawable/my_icon" ...>
  ...
</activity | service>
```
अगर आपका बोला गया निर्देश, बोले गए निर्देश का इस्तेमाल करके कोई गतिविधि शुरू करता है, तो बोले गए टेक्स्ट को लेख में बदले गए कोड के साथ पाएं (जैसे कि onResume() में):
```
ArrayList<String> voiceResults = getIntent().getExtras()
        .getStringArrayList(RecognizerIntent.EXTRA_RESULTS);
```
अगर बोले गए निर्देश से कोई सेवा शुरू होती है, तो इंटेंट इंटेंट अतिरिक्त विकल्प onStartCommand() कॉलबैक में उपलब्ध होता है:
```
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    ArrayList<String> voiceResults = intent.getExtras()
            .getStringArrayList(RecognizerIntent.EXTRA_RESULTS);
    // ...
}
```

सेटिंग कंस्ट्रेंट

अगर आपको अपना Glassware प्रारंभ करने के लिए निम्न में से एक या सभी सुविधाओं की आवश्यकता है, तो उन्हें res/xml/<my_voice_trigger>.xml संसाधन में बताएं. अगर ये सुविधाएं उपलब्ध नहीं हैं, तो Glass बोले गए निर्देश को बंद कर देता है:

camera
network

microphone

<trigger command="POST_AN_UPDATE">
    <constraints
        camera="true"
        network="true" />
</trigger>

बोलकर दिए जाने वाले काम के निर्देश

उपयोगकर्ता को बोलकर दिए जाने वाले निर्देश की मदद से, अलग-अलग गतिविधियों को पूरा करने की सुविधा दी जा सकती है. आप मानक Android मेन्यू एपीआई के ज़रिए प्रासंगिक बोले गए निर्देश तैयार करते हैं लेकिन उपयोगकर्ता, टच के बजाय बोलकर निर्देश देने की सुविधा के ज़रिए मेन्यू आइटम शुरू कर सकते हैं.

किसी खास गतिविधि के लिए, बोलकर दिए जाने वाले निर्देश चालू करने के लिए:

बोलकर निर्देश देने की सुविधा को चालू करने के लिए, अपनी पसंद की गतिविधि में getWindow().requestFeature(WindowUtils.FEATURE_VOICE_COMMANDS) को कॉल करें. जब यह सुविधा चालू होती है, तब जब भी इस गतिविधि पर फ़ोकस किया जाता है, तो "ok ग्लास" मेन्यू, स्क्रीन के फ़ुटर में दिखाई देता है.
onCreatePanelMenu() को ओवरराइड करें और उस मामले को हैंडल करें जब WindowUtils.FEATURE_VOICE_COMMANDS चालू है. अगर यह सुविधा चालू है, तो एक बार मेन्यू सेट अप करें. जैसे, किसी मेन्यू रिसॉर्स को इनफ़्लेट करना या वॉइस मेन्यू सिस्टम बनाने के Menu.add() तरीके अपनाएं.

उपयोगकर्ताओं के बोलने पर, बोलकर दिए जाने वाले निर्देशों को मैनेज करने के लिए, onMenuItemSelected() को बदलें. जब उपयोगकर्ता मेन्यू आइटम को चुन लेता है, तो स्क्रीन के फ़ुटर सेक्शन में "ठीक है, ग्लास" बोलकर निर्देश देने की सुविधा अपने-आप दिख जाती है. हालांकि, यह तब तक होती है, जब तक कोई नई बात सेट रहती है.

नीचे दिए गए कोड से, बोलकर दिए जाने वाले निर्देशों की सुविधा चालू हो जाती है. ज़रूरत पड़ने पर मेन्यू के मेन्यू को बड़ा कर दिया जाता है और बोले जाने वाले निर्देश मैनेज किए जाते हैं.

public class ContextualMenuActivity extends Activity {

    @Override
    protected void onCreate(Bundle bundle) {
        super.onCreate(bundle);

        // Requests a voice menu on this activity. As for any other
        // window feature, be sure to request this before
        // setContentView() is called
        getWindow().requestFeature(WindowUtils.FEATURE_VOICE_COMMANDS);
        setContentView(R.layout.activity_main);
    }

    @Override
    public boolean onCreatePanelMenu(int featureId, Menu menu) {
        if (featureId == WindowUtils.FEATURE_VOICE_COMMANDS) {
            getMenuInflater().inflate(R.menu.main, menu);
            return true;
        }
        // Pass through to super to setup touch menu.
        return super.onCreatePanelMenu(featureId, menu);
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

    @Override
    public boolean onMenuItemSelected(int featureId, MenuItem item) {
        if (featureId == WindowUtils.FEATURE_VOICE_COMMANDS) {
            switch (item.getItemId()) {
                case R.id.dogs_menu_item:
                    // handle top-level dogs menu item
                    break;
                case R.id.cats_menu_item:
                    // handle top-level cats menu item
                    break;
                case R.id.lab_menu_item:
                    // handle second-level labrador menu item
                    break;
                case R.id.golden_menu_item:
                    // handle second-level golden menu item
                    break;
                case R.id.calico_menu_item:
                    // handle second-level calico menu item
                    break;
                case R.id.cheshire_menu_item:
                    // handle second-level cheshire menu item
                    break;
                default:
                    return true;
            }
            return true;
        }
        // Good practice to pass through to super if not handled
        return super.onMenuItemSelected(featureId, item);
    }
}

यहां पिछली गतिविधि में इस्तेमाल किए गए मेन्यू रिसॉर्स का उदाहरण दिया गया है. ध्यान दें कि हैरारकी वॉइस मेन्यू सिस्टम के लिए, नेस्ट किए गए मेन्यू आइटम कैसे बनाए जा सकते हैं. नीचे दिए गए उदाहरण में, मेन्यू के पहले आइटम को इस तरह से ऐक्सेस किया जा सकता है: ok ग्लास, मुझे कुत्ते दिखाएं, लैब्राडोर.

<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <!-- Use the constants defined in the ContextualMenus.Command enum-->
    <item
        android:id="@+id/dogs_menu_item"
        android:title="@string/show_me_dogs">
        <menu>
            <item
                android:id="@+id/lab_menu_item"
                android:title="@string/labrador" />
            <item
                android:id="@+id/golden_menu_item"
                android:title="@string/golden" />
        </menu>
    </item>
    <item
        android:id="@+id/cats_menu_item"
        android:title="@string/show_me_cats">
        <menu>
            <item
                android:id="@+id/cheshire_menu_item"
                android:title="@string/cheshire" />
            <item
                android:id="@+id/calico_menu_item"
                android:title="@string/calico" />
        </menu>
    </item>
</menu>

<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <!-- Use the constants defined in the ContextualMenus.Command enum-->
    <item
        android:id="@+id/play_menu_item"
        android:title="PLAY_MUSIC" />
    <item
        android:id="@+id/pause_menu_item"
        android:title="PAUSE_MUSIC" />
</menu>

(ज़रूरी नहीं) बदलें onPreparePanel(), देखें कि WindowUtils.FEATURE_VOICE_COMMANDS चालू है या नहीं. चालू होने पर, मेन्यू सिस्टम सेट अप करने के लिए दूसरे तरीके अपनाए जा सकते हैं. जैसे, कुछ ज़रूरी शर्तों के आधार पर, मेन्यू के कुछ आइटम जोड़ना और हटाना. किसी खास शर्त के हिसाब से, काम के वॉइस मेन्यू को भी चालू या बंद किया जा सकता है (दोतरफ़ा true) और बंद (false देखें). उदाहरण के लिए:
```
    private boolean mVoiceMenuEnabled;
    ...
    @Override
    public boolean onPreparePanel(int featureId, View view, Menu menu) {
        if (featureId == WindowUtils.FEATURE_VOICE_COMMANDS) {
        // toggle this boolean on and off based on some criteria
            return mVoiceMenuEnabled;
        }
        // Good practice to call through to super for other cases
        return super.onPreparePanel(featureId, view, menu);
    }
```

आवाज़ और टच मेन्यू की सुविधा एक साथ इस्तेमाल की जा सकती है

प्रासंगिक वॉइस कमांड मौजूदा Android मेन्यू एपीआई का इस्तेमाल करते हैं, इसलिए आप टच मेन्यू के लिए पहले से मौजूद बहुत सारे कोड और संसाधनों का फिर से इस्तेमाल कर सकते हैं और दोनों तरह के मेन्यू पर काम कर सकते हैं.

आपको बस WindowUtils.FEATURE_VOICE_COMMANDS सुविधा के अलावा, Window.FEATURE_OPTIONS_PANEL सुविधा की जांच करनी होगी. हो सकता है कि आप कुछ ही तरीकों से यह जांच कर रहे हों. इसके बाद, बस उपयोगकर्ता को कुछ टैप करके, टच मेन्यू खोलने के लिए एक तरीका जोड़ें, जैसे कि एक टैप में.

उदाहरण के लिए, इस तरह के टच मेन्यू की सुविधा जोड़ने के लिए, पिछली गतिविधि के उदाहरण में बदलाव किया जा सकता है (बदलाव लागू होते हैं):

// 1. Check for Window.FEATURE_OPTIONS_PANEL
// to inflate the same menu resource for touch menus.
@Override
public boolean onCreatePanelMenu(int featureId, Menu menu) {
    if (featureId == WindowUtils.FEATURE_VOICE_COMMANDS ||
            featureId == Window.FEATURE_OPTIONS_PANEL) {
    ...
}

// 2. Check for Window.FEATURE_OPTIONS_PANEL
// to handle touch menu item selections.
@Override
public boolean onMenuItemSelected(int featureId, MenuItem item) {
    if (featureId == WindowUtils.FEATURE_VOICE_COMMANDS ||
            featureId == Window.FEATURE_OPTIONS_PANEL) {
    ...
}

इन बदलावों के साथ, आप अपना मेन्यू दिखाने के लिए टैप कर सकते हैं या ओके ग्लास बोल सकते हैं.

डेवलपमेंट के लिए 'सबके लिए मौजूद नहीं' के तौर पर सेट किए गए निर्देशों का इस्तेमाल करना

जब आप अपना Glassware वितरित करना चाहें, तो आपको VoiceTriggers.Command में स्वीकृत मुख्य ध्वनि आदेशों और ContextualMenus.Command में प्रासंगिक प्रासंगिक बोले गए आदेशों का उपयोग करना होगा.

अगर आपको उन बोले गए निर्देशों का इस्तेमाल करना है जो GDK में उपलब्ध नहीं हैं, तो आप अपनी AndroidManifest.xml फ़ाइल में Android अनुमति का अनुरोध कर सकते हैं:

<uses-permission
     android:name="com.google.android.glass.permission.DEVELOPMENT" />

सूची में शामिल मुख्य बोले गए निर्देशों का इस्तेमाल करना

res/values/strings.xml में एक ऐसी स्ट्रिंग वैल्यू के बारे में बताएं जो आपकी आवाज़ के ट्रिगर का नाम बताती हो. वैकल्पिक रूप से अपने Glassware को प्रारंभ करने से पहले वाक् पहचान Glassware दिखाने के लिए ध्वनि संकेत की घोषणा करें.
```
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="glass_voice_trigger">read me a story</string>
    <string name="glass_voice_prompt">what story?</string>
</resources>
```
वॉइस ट्रिगर के लिए, res/xml/<my_voice_trigger>.xml में एक्सएमएल संसाधन बनाएं. सबके लिए मौजूद नहीं दिए गए बोले जाने वाले निर्देशों के लिए, आपको command से जुड़े एट्रिब्यूट के बजाय keyword एट्रिब्यूट का इस्तेमाल करना चाहिए. keyword एट्रिब्यूट, उस स्ट्रिंग रिसॉर्स का रेफ़रंस होना चाहिए जो बोलकर दिए जाने वाले निर्देश की जानकारी देता है. किसी गतिविधि या सेवा को तुरंत शुरू करने वाले आसान वॉइस ट्रिगर के लिए, trigger एलिमेंट की जानकारी दें:
```
<?xml version="1.0" encoding="utf-8"?>
<trigger keyword="@string/glass_voice_trigger" />
```
ऐसा वॉइस ट्रिगर बनाने के लिए जो उपयोगकर्ता को आपकी गतिविधि या सेवा शुरू करने से पहले कोई अतिरिक्त वाक्यांश बोलने का संकेत दे, एक इनपुट एलिमेंट भी शामिल करें:
```
<?xml version="1.0" encoding="utf-8"?>
<trigger keyword="@string/glass_voice_trigger">
    <input prompt="@string/glass_voice_prompt" />
</trigger>
```

सूची से चुने गए, बोले गए निर्देशों का इस्तेमाल करना

मेन्यू आइटम बनाते समय, मेन्यू आइटम के शीर्षक के लिए किसी भी टेक्स्ट का इस्तेमाल करें. उदाहरण के लिए:

<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <!-- Use the constants defined in the ContextualMenus.Command enum-->
    <item
        android:id="@+id/pizza_menu_item"
        android:title="@string/find_pizza" />
</menu>

बोली पहचानने की सुविधा चालू की जा रही है

बोली पहचान Glassware उपयोगकर्ताओं के बोलने का इंतज़ार करता है और बोलना पूरा होने के बाद प्रतिलेखन किया गया लेख लौटाता है. गतिविधि शुरू करने के लिए:

ACTION_RECOGNIZE_SPEECH इंटेंट के साथ startActivityForResult() को कॉल करें. गतिविधि शुरू करते समय, ये इंटेंट अतिरिक्त काम करते हैं:

बोली जा रही बोली को लेख में बदलने की सुविधा को, EXTRA_RESULTS से सेव किया गया टेक्स्ट पढ़ने के लिए, onActivityResult() कॉलबैक को बदलें. इस कॉलबैक को तब कॉल किया जाता है, जब उपयोगकर्ता बोलना बंद कर देते हैं.

private static final int SPEECH_REQUEST = 0;

private void displaySpeechRecognizer() {
    Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
    startActivityForResult(intent, SPEECH_REQUEST);
}

@Override
protected void onActivityResult(int requestCode, int resultCode,
        Intent data) {
    if (requestCode == SPEECH_REQUEST && resultCode == RESULT_OK) {
        List<String> results = data.getStringArrayListExtra(
                RecognizerIntent.EXTRA_RESULTS);
        String spokenText = results.get(0);
        // Do something with spokenText.
    }
    super.onActivityResult(requestCode, resultCode, data);
}