iOS पर Structure APIs

iOS के लिए Home APIs के ज़रिए, स्ट्रक्चर के लिए एपीआई ऐक्सेस किए जा सकते हैं.

स्ट्रक्चर एपीआई का इस्तेमाल करने के लिए, सबसे पहले GoogleHomeSDK पैकेज को अपने ऐप्लिकेशन में इंपोर्ट करें:

import GoogleHomeSDK

गड़बड़ी ठीक करना

Home API में कुछ ऐसे तरीके हैं जो HomeError थ्रो करते हैं. इसलिए, हमारा सुझाव है कि आप do-catch ब्लॉक का इस्तेमाल करके, उन कॉल पर HomeError को पकड़ें.

HomeError को मैनेज करते समय, उसके code और message फ़ील्ड की जांच करें. इससे आपको गड़बड़ी के बारे में पता चलेगा.

जिन गड़बड़ियों को ठीक नहीं किया गया है उनकी वजह से, आपका ऐप्लिकेशन क्रैश हो जाएगा.

ज़्यादा जानकारी के लिए, गड़बड़ी ठीक करना लेख पढ़ें.

Structure API

Home होम ग्राफ़ को दिखाता है. साथ ही, यह Structure API का एंट्री पॉइंट है. इससे स्ट्रक्चर, कमरों, और डिवाइसों के रेफ़रंस मिलते हैं.

Structure, आपके होम ग्राफ़ में मौजूद स्ट्रक्चर को दिखाता है. इससे id और name जैसे स्ट्रक्चर मेटाडेटा का ऐक्सेस मिलता है.

अपने खाते में मौजूद सभी स्ट्रक्चर पाने के लिए, structures() का इस्तेमाल करें. स्ट्रक्चर को Query के तौर पर दिखाया जाता है. इससे, इसके डेटा को इस्तेमाल करने के कई तरीके मिलते हैं:

ऐसा हो सकता है कि structures().list() कॉल, तुरंत स्ट्रक्चर का मान्य सेट न दिखाए. अगर आपका ऐप्लिकेशन, यूज़र इंटरफ़ेस (यूआई) को चलाने के लिए, स्ट्रक्चर में होने वाले सभी बदलावों को सब्सक्राइब करने के लिए stream() को कॉल करता है, तो स्ट्रक्चर की मान्य सूची आखिर में वापस मिलनी चाहिए. ऐसी अन्य स्थितियां भी हो सकती हैं, जब स्ट्रक्चर की खाली सूची दिखाई जा सकती है. उदाहरण के लिए, अगर उपयोगकर्ता के फ़ोन का इंटरनेट कनेक्शन बंद हो जाता है या उपयोगकर्ता ने आपके ऐप्लिकेशन को दी गई अनुमतियां रद्द कर दी हैं. आपको अपने ऐप्लिकेशन में इन मामलों को हैंडल करना चाहिए.

@Published public private(set) var structures: [Structure] = []
private var structuresCancellable: AnyCancellable?

  self.structuresCancellable = home
    .structures()
    .batched()
    .receive(on: DispatchQueue.main)
    .map { Array($0) }
    .catch {
      Logger.error("Failed to load structures: \($0)")
      return Just([Structure]())
    }
    .assign(to: \.structures, on: self)

स्ट्रक्चर कॉल के सैंपल

स्ट्रक्चर का सेट पाना

Query<Structure> पर list() को कॉल करने पर, एलिमेंट का सबसे हाल का सेट मिलता है:

// Get a stream of all structures accessible to the user
let allStructuresChanges = try await self.home.structures()
let allStructures = try? await allStructuresChanges.list()

रिऐक्टिव ऐप्लिकेशन डिज़ाइन करते समय, आपको list() के बजाय batched() और stream() कॉल का इस्तेमाल करना चाहिए. ऐसा इसलिए, क्योंकि होम ग्राफ़ में बदलाव होने पर ये अपने-आप डेटा जनरेट करते हैं.

स्ट्रक्चर की प्रॉपर्टी पाना

स्ट्रक्चर की सूची की मदद से, इनके लिए प्रॉपर्टी ऐक्सेस की जा सकती हैं:

// Get a stream of changes taking place on a structure.
let structureChanges = try await home.structures().list().filter { $0.id == structureID }

// Get a snapshot of the structure.
let structure = try await structureChanges.first!

// Get structure properties
print("id \(structure.id) ")
print("name \(structure.name) ")

नाम के हिसाब से स्ट्रक्चर ढूंढना

अगर आपको किसी स्ट्रक्चर का नाम पता है, तो name प्रॉपर्टी का इस्तेमाल करके भी उसे ऐक्सेस किया जा सकता है:

do {
  structure1 = try await home.structures().list().first(where: { $0.name == "Main House" })
} catch let error as HomeError {
  // Code for handling the exception
}

यहां से, हर स्ट्रक्चर के लिए प्रॉपर्टी, कमरे, और डिवाइसों को ऐक्सेस किया जा सकता है.

एक से ज़्यादा स्ट्रक्चर के साथ काम करना

एक से ज़्यादा स्ट्रक्चर का इस्तेमाल करने के लिए, हर स्ट्रक्चर का अलग रेफ़रंस पाएं:

var structure1: Structure!
var structure2: Structure!
do {
  structure1 = try await home.structures().list().first(where: { $0.name == "Main House" })
} catch let error as HomeError {
  // Code for handling the exception
}
do {
  structure2 = try await home.structures().list().first(where: { $0.name == "Guest Cottage" })
} catch let error as HomeError {
  // Code for handling the exception
}

कमरे

किसी रूम में डिवाइसों का ग्रुप होता है. कोई कमरा हमेशा किसी स्ट्रक्चर का हिस्सा होता है और किसी स्ट्रक्चर में कई कमरे हो सकते हैं. किसी स्ट्रक्चर से किसी कमरे को हटाने पर, उस कमरे में मौजूद डिवाइस स्ट्रक्चर से नहीं हटते. हालांकि, अगर कमरा मिटा दिया जाता है, तो उस कमरे में मौजूद डिवाइसों को किसी भी कमरे के लिए असाइन नहीं किया जाता.

खाते में मौजूद सभी कमरों को वापस पाने के लिए, Home.rooms() का इस्तेमाल करें. इसके बाद, हर कमरे में मौजूद डिवाइसों को दिखाने के लिए, roomID = device.roomID का इस्तेमाल करें.

self.home.rooms().batched()
  .combineLatest(self.home.devices().batched())
  .receive(on: DispatchQueue.main)
  .catch { error in
    Logger.error("Failed to load rooms and devices: \(error)")
    return Just((Set<Room>(), Set<HomeDevice>()))
  }
  .map { rooms, devices in
    var devicesByRoom = [Room: [HomeDevice]]()
    for room in rooms where room.structureID == currentStructureID {
      devicesByRoom[room] = devices.filter { $0.roomID == room.id }
    }
    return devicesByRoom
  }.assign(to: &self.$devicesByRoom)

Room के कॉल के सैंपल

चैट रूम की सूची पाना

Home क्लास का इस्तेमाल करके, कमरों की सूची पाई जा सकती है. साथ ही, उनके लिए प्रॉपर्टी ऐक्सेस की जा सकती हैं:

let allRoomsChanges = self.home.rooms()
let allRooms = try await allRoomsChanges.list()
let room = allRooms.first!
XCTAssertTrue(allRooms.contains(room))

print("id \(room.id) ")
print("name \(room.name) ")

चैट रूम बनाएं

Structure में नया रूम बनाने के लिए:

let testName = "Test Room Name"
var newRoom: Room!
do {
  newRoom = try await structure.createRoom(name: testName)
  XCTAssertNotNil(newRoom)
} catch let error as HomeError {
  // Code for handling the exception
}

किसी रूम को मिटाना

इसके अलावा, चैट रूम को मिटाने के लिए:

val roomToDelete = structure.rooms().list().filter { it.name == "room_id1" }.firstOrNull()
    structure.deleteRoom(roomToDelete!!)

रूम के आईडी का इस्तेमाल करके भी रूम को मिटाया जा सकता है:

let roomToDelete = allRooms.first(where: { $0.id == room.id })
if let roomToDelete1 = roomToDelete {
  do {
    try await structure.deleteRoom(roomToDelete1)
  } catch let error as HomeError {
    // Code for handling the exception
  }
}

अगर डिवाइसों वाले किसी रूम को मिटा दिया जाता है, तो डिवाइस अब भी स्ट्रक्चर में मौजूद रहेंगे. हालांकि, उन्हें किसी रूम के लिए असाइन नहीं किया जाएगा.

डिवाइसों को किसी दूसरे कमरे में ले जाना

Structure की मदद से, किसी डिवाइस को दूसरे रूम में भी ट्रांसफ़र किया जा सकता है:

do {
  try await structure.move(device: light, to: room)
} catch let error as HomeError {
  // Code for handling the exception
}

किसी रूम का नाम बदलना

किसी रूम का नाम बदलने के लिए, setName(_:) तरीके को कॉल करें:

let updatedRoom = try await theRoom.setName("new room name")

किसी रूम का नाम बदलने पर, ओरिजनल Room स्ट्रक्चर में कोई बदलाव नहीं होता. हालांकि, अपडेट किए गए Room ऑब्जेक्ट में बदलाव दिखता है.

अगर नाम में 60 यूनिकोड कोड पॉइंट (वर्ण) से ज़्यादा हैं, तो उन्हें छोटा कर दिया जाएगा. हालांकि, कोई गड़बड़ी नहीं दिखेगी. डेवलपर की यह ज़िम्मेदारी है कि वे लंबे नामों को मैनेज करें. उदाहरण के लिए, वे यह तय कर सकते हैं कि उन्हें उपयोगकर्ताओं को यह सूचना देनी है या नहीं कि नाम छोटा कर दिया जाएगा.

एपीआई की सूची

Home का इंस्टेंस बनने के बाद, इसके ज़रिए इन स्ट्रक्चर एपीआई को ऐक्सेस किया जा सकता है:

Structure में ये एपीआई शामिल हैं:

Room में ये एपीआई शामिल हैं: