Glass Explorer Edition SDK टूल अब काम नहीं करता. यह दस्तावेज़ एक ऐतिहासिक रेफ़रंस के तौर पर अब भी मौजूद है.

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

जगह की जानकारी और सेंसर

जगह की जानकारी और सेंसर डेटा ऐक्सेस करने के लिए, स्टैंडर्ड Android का इस्तेमाल किया जा सकता है प्लैटफ़ॉर्म एपीआई.

जगह

Glass पर स्थान में मानक Android का उपयोग करना शामिल है जगह की जानकारी का डेटा पाने के लिए प्लैटफ़ॉर्म एपीआई लोकेशन प्रोवाइडर.

जगह की जानकारी का डेटा पाने के लिए, आपको Android SDK टूल की इन क्लास का इस्तेमाल करना होगा:

LocationManager – Android लोकेशन सिस्टम सेवा का ऐक्सेस देता है एक ऐसी कंपनी है जो LocationProvider.
LocationProvider – यह कुछ शर्तों के आधार पर, जगह की जानकारी का डेटा देता है. Glass खास "रिमोट" देता है सेवा देने वाली कंपनियां जो आपको ऐसे जोड़े गए डिवाइस से जगह की जानकारी का डेटा पाने की सुविधा देता है जिसमें MyGlass है साथी ऐप्लिकेशन इंस्टॉल किया गया.
Criteria – आपको मानदंड का एक सेट बनाने देता है, आपकी सेट की गई शर्तों के हिसाब से, सबसे अच्छे LocationProvider को चुनता है.

खास जानकारी

स्थान का डेटा प्राप्त करने के लिए, आपको LocationManager क्लास का इस्तेमाल करें.

Android फ़ोन या टैबलेट पर मौजूद ऐप्लिकेशन, आस-पास मौजूद डिवाइस से जगह की जानकारी का डेटा हासिल करते हैं डिवाइस पर जीपीएस और नेटवर्क की जगह की जानकारी देने वाली कंपनियां. हालांकि, Glass पर उपलब्ध जगह बताने वाली कंपनियों का सेट डायनैमिक होता है और उसमें रिमोट शामिल हो सकता है लोकेशन प्रोवाइडर, जो किसी अन्य सोर्स से जगह की जानकारी का डेटा देते हैं, जैसे कि ब्लूटूथ से जुड़ा ऐसा डिवाइस जिसमें MyGlass साथी ऐप्लिकेशन इंस्टॉल है. हैंडल करने के लिए ये अतिरिक्त सेवा देने वाली कंपनियां, कई कंपनियों से जगह की जानकारी के अपडेट को सुनें सेवा देने वाली कंपनियों पर निर्भर करता है.

जगह की जानकारी देने वाली सभी उपलब्ध कंपनियों से डेटा मांगने के लिए:

Criteria बनाएं ऑब्जेक्ट को अपनी जगह की जानकारी से जुड़ी ज़रूरी शर्तों के साथ सबमिट करें.
getProviders() पर कॉल करें का इस्तेमाल करें.
सेवा देने वाली कंपनियों की सूची को दोहराएं और उन सभी से अपडेट पाने का अनुरोध करें. इससे यह पक्का होता है कि आपको रिमोट सेवा देने वाली कंपनियां, अगर वे उपलब्ध है लेकिन Glass पर स्थानीय सेवा देने वाली कंपनियों की ओर से भी उपलब्ध है (जैसे कि वायरलेस नेटवर्क सेवा देने वाली कंपनी).

हर उदाहरण के साथ दी गई सटीक जानकारी और समय की जानकारी का इस्तेमाल करें अपडेट करके तय करें कि अपडेट अच्छा है या आपको एक और जवाब का इंतज़ार करें.

LocationManager locationManager; // initialized elsewhere

// This example requests fine accuracy and requires altitude, but
// these criteria could be whatever you want.
Criteria criteria = new Criteria();
criteria.setAccuracy(Criteria.ACCURACY_FINE);
criteria.setAltitudeRequired(true);

List<String> providers = locationManager.getProviders(
        criteria, true /* enabledOnly */);

for (String provider : providers) {
    locationManager.requestLocationUpdates(provider, minTime,
            minDistance, listener);
}

सेंसर

ग्लास

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

नीचे दिए गए उदाहरण में, इस हिसाब से गेम के स्कोर के अपडेट को ब्लॉक किया जाता है और गेम को देरी से खेला जाता है उपयोगकर्ता ने अपने सिर से Glass हटा दिया है:

लागू करने के लिए BroadcastReceiver का इस्तेमाल नहीं किया जा सकता.
अपनी सेवा में, onCreate() तरीका अपनाएं और उस रिसीवर को रजिस्टर करें जो ACTION_ON_HEAD_STATE_CHANGE इंटेंट.

इस onDestroy() पाने वाले का रजिस्ट्रेशन रद्द करें.

import com.google.android.glass.content.Intents;
...

public class LiveCardService extends Service {

    ...
    private boolean mIsStopped = false;

    private final BroadcastReceiver broadCastReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {

            if (Intents.ACTION_ON_HEAD_STATE_CHANGED.equals(intent.getAction())) {
                boolean onHead = intent.getBooleanExtra(Intents.EXTRA_IS_ON_HEAD,
                        false);
                if (onHead) {
                    mDelay = LiveCardService.DELAY_MILLIS;
                    if (isStopped()) {
                        // Resume updating scores
                        setStop(false);

                        // Restart immediately to get a refreshed score
                        mHandler.postDelayed(mUpdateLiveCardRunnable, 0);
                    }
                } else {
                    // Increase the delay when the device is off head
                    mDelay = LiveCardService.DELAY_MILLIS_EXT;
                }
            }
        }
    };

    private final Runnable mUpdateLiveCardRunnable = new Runnable() {

        @Override
        public void run() {

            if (mDelay == DELAY_MILLIS_EXT) {
                // Count the increased delay as a retry attempt
                mRetryCount++;
            } else if (mDelay == DELAY_MILLIS) {
                mRetryCount = 0;
            }

            if (mRetryCount > MAX_RETRIES) {
                // Stop updating scores
                mIsStopped = true;
            }

            if (!isStopped()) {
                // Generate fake points.
                homeScore += mPointsGenerator.nextInt(3);
                awayScore += mPointsGenerator.nextInt(3);

                // Update the remote view with the new scores.
                mLiveCardView = getRemoteViews(homeScore, awayScore);

                // Always call setViews() to update the live card's RemoteViews.
                mLiveCard.setViews(mLiveCardView);

                // Queue another score update in 30 seconds.
                mHandler.postDelayed(mUpdateLiveCardRunnable, mDelay);
            }
        }
    };

    @Override
    public void onCreate() {
        super.onCreate();
        mPointsGenerator = new Random();
        mDelay = DELAY_MILLIS;

        registerReceiver(broadCastReceiver, new IntentFilter(
                Intents.ACTION_ON_HEAD_STATE_CHANGED));
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        if (mLiveCard == null) {

            // Get an instance of a live card
            mLiveCard = new LiveCard(this, LIVE_CARD_TAG);

            // Inflate a layout into a remote view
            mLiveCardView = new RemoteViews(getPackageName(),
                    R.layout.live_card);

            // Set up initial RemoteViews values
            homeScore = 0;
            awayScore = 0;
            mLiveCardView = getRemoteViews(homeScore, awayScore);

            // Set up the live card's action with a pending intent
            // to show a menu when tapped
            Intent menuIntent = new Intent(this, LiveCardMenuActivity.class);
            menuIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK |
                    Intent.FLAG_ACTIVITY_CLEAR_TASK);
            mLiveCard.setAction(PendingIntent.getActivity(
                    this, 0, menuIntent, 0));

            // Publish the live card
            mLiveCard.publish(PublishMode.REVEAL);

            // Queue the update text runnable
            mHandler.post(mUpdateLiveCardRunnable);
        }

        return START_STICKY;
    }

    @Override
    public void onDestroy() {
        if (mLiveCard != null && mLiveCard.isPublished()) {
            //Stop the handler from queuing more Runnable jobs
            setStop(true);

            mLiveCard.unpublish();
            mLiveCard = null;
        }

        unregisterReceiver(broadCastReceiver);

        super.onDestroy();
    }

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    private RemoteViews getRemoteViews(int homeScore, int awayScore) {
        RemoteViews remoteViews = new RemoteViews(getPackageName(),
                R.layout.live_card);

        remoteViews.setTextViewText(R.id.home_team_name_text_view,
                getString(R.string.home_team));
        remoteViews.setTextViewText(R.id.away_team_name_text_view,
                getString(R.string.away_team));
        remoteViews.setTextViewText(R.id.footer_text,
                getString(R.string.game_quarter));

        remoteViews.setTextViewText(R.id.home_score_text_view,
                String.valueOf(homeScore));
        remoteViews.setTextViewText(R.id.away_score_text_view,
                String.valueOf(awayScore));
        return remoteViews;
    }

    public boolean isStopped() {
        return mIsStopped;
    }

    public void setStop(boolean isStopped) {
        mIsStopped = isStopped;
    }
}

Android

Glass पर निम्न Android सेंसर समर्थित हैं:

TYPE_ACCELEROMETER
TYPE_GRAVITY
TYPE_GYROSCOPE
TYPE_LIGHT
TYPE_LINEAR_ACCELERATION
TYPE_MAGNETIC_FIELD
TYPE_ORIENTATION (अब सेवा में नहीं है)
TYPE_ROTATION_VECTOR

नीचे दिए गए Android सेंसर काम नहीं करते:

Glass पर सेंसर का इस्तेमाल करते समय यहां कुछ सलाह दी गई है:

ग्लास सेंसर कोऑर्डिनेट सिस्टम को नीचे ग्लास डिसप्ले के हिसाब से दिखाया गया है. ज़्यादा जानकारी के लिए, यह देखें सेंसर कोऑर्डिनेट सिस्टम का इस्तेमाल करें.

एक्सलरोमीटर, जाइरोस्कोप, और मैग्नेटोमीटर Glass डिवाइस के ऑप्टिक्स पॉड पर स्थित हैं, जिसे उपयोगकर्ता अपनी नज़र के हिसाब से डिवाइस को घुमाते हैं. आप का कोण सीधे ऑप्टिक्स पॉड का है, इसलिए इस समय इसका ध्यान रखें कंपास हेडिंग जैसे ऐप्लिकेशन के लिए इन सेंसर के कोणों का उपयोग करके.
बैटरी लाइफ़ बढ़ाने के लिए, सेंसर का इस्तेमाल सिर्फ़ तब करें, जब आपको उनकी ज़रूरत हो. उदाहरण के लिए, अगर आपका ग्लासवेयर Service का इस्तेमाल करके, LiveCard सेंसर की ज़रूरत सिर्फ़ तब होगी, जब लाइव कार्ड दिख रहा होगा. इसके लिए, LiveCard सेंसर को सुनना शुरू करने और बंद करने के लिए, कॉलबैक के तरीके दिखाते हैं.
सेंसर इवेंट कॉलबैक, यूज़र इंटरफ़ेस (यूआई) थ्रेड पर चलते हैं. इसलिए, इवेंट प्रोसेस करें और इस तरह वापस आएं जल्द से जल्द. सेंसर इवेंट को सूची में पुश करें और बैकग्राउंड थ्रेड का इस्तेमाल करें अगर आपकी प्रोसेसिंग में ज़्यादा समय लगता है, तो उन्हें हैंडल किया जा सकता है.
सिर की गतिविधि को ट्रैक करने के लिए अक्सर 50 हर्ट्ज़ देना काफ़ी होता है.

सेंसर इस्तेमाल करने के तरीके के बारे में ज़्यादा जानने के लिए, यहां देखें Android डेवलपर गाइड.