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

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

जगह और सेंसर

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

जगह

जगह की जानकारी देने वाली सेवा में, जगह की जानकारी देने वाली उपलब्ध कंपनियों से जगह की जानकारी का डेटा पाने के लिए, सामान्य 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);
}

सेंसर

शीशा

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

नीचे दिए गए उदाहरण में गेम के स्कोर को अपडेट करने और उसे बंद करने का समय शामिल है. यह इस बात पर निर्भर करता है कि उपयोगकर्ता ने गेंद को अपने सिर से हटा दिया है या नहीं:

स्थिति में बदलाव को मैनेज करने के लिए 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 डिवाइस के ऑप्टिक्स पॉड पर मौजूद हैं. उपयोगकर्ता, डिवाइस को अपनी नज़र के मुताबिक अलाइन करते हैं. आप सीधे तौर पर ऑप्टिक्स पॉड को माप नहीं सकते. इसलिए, कंपास हेडिंग जैसे ऐप्लिकेशन के लिए इन सेंसर से ऐंगल का इस्तेमाल करते समय इस बात का ध्यान रखें.
बैटरी लाइफ़ बचाने के लिए, सेंसर को सिर्फ़ तब सुनें, जब आपको उनकी ज़रूरत हो. उदाहरण के लिए, अगर आपका Glassware, LiveCard को रेंडर करने के लिए Service का इस्तेमाल करता है और लाइव कार्ड के दिखने पर ही आपको सेंसर की ज़रूरत होती है, तो सेंसर सुनना शुरू और बंद करने के लिए, LiveCard कॉलबैक के तरीके इस्तेमाल करें.
सेंसर इवेंट के कॉलबैक, यूज़र इंटरफ़ेस (यूआई) थ्रेड पर चलाए जाते हैं. इसलिए, इवेंट जल्दी से प्रोसेस किए जाते हैं और जल्द से जल्द दिखाए जाते हैं. अगर आपकी प्रोसेसिंग में बहुत ज़्यादा समय लगता है, तो सेंसर इवेंट को सूची में भेजें और बैकग्राउंड थ्रेड का इस्तेमाल करें.
आम तौर पर, 50 हर्ट्ज़ की रफ़्तार का सैंपल लेने में लगने वाला समय, हेड मोशन की ट्रैकिंग के लिए काफ़ी होता है.

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