iOS पर Structure APIs

bookmark_border संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

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

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

import GoogleHomeSDK

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

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

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
}

एपीआई की सूची

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

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

Room में ये एपीआई हैं: