When using TootSDK within a macOS target you will need to enable the com.apple.security.network.client entitlement in your entitlements file or within the Signing & Capabilities tab in Xcode.

<key>com.apple.security.network.client</key>
<true/>

There are several different types of timeline in TootSDK that you can access, for example their home timeline, the local timeline of their instance, or the federated timeline. These are all enumerated in the Timeline enum.

You can retrieve the latest posts (up to 40 on Mastodon) with a call like so:

let items = try await client.getTimeline(.home)
let posts = items.result

TootSDK returns Posts, Accounts, Lists and DomainBblocks as PagedResult. In our code, items is a PagedResult struct. It contains a property called result which will be the type of data request (in this case an array of Post).

Some requests in TootSDK allow pagination in order to request more information. TootSDK can request a specific page using the PagedInfo struct and handles paginaged server responses using the PagedResult struct.

PagedInfo has the following properties:

• maxId (Return results older than ID)
• minId (Return results immediately newer than ID)
• sinceId (Return results newer than ID)

So for example, if we want all posts from the user's home timeline that are newer than post ID 100, we could write:

let items = try await client.getTimeline(.home, PagedInfo(minId: 100))
let posts = items.result

Paged requests also deliver a PagedInfo struct as a property of the PagedResult returned, which means you can use that for subsequent requests of the same type.

var pagedInfo: PagedInfo?
var posts: [Post] = []

func retrievePosts() async {
    let items = try await client.getTimeline(.home, pagedInfo)
    posts.append(contentsOf: items.result)    
    self.pagedInfo = items.pagedInfo
}

TootSDK implements several facilities to make it easier to iterate over multiple pages using the hasPrevious, hasNext, previousPage and nextPage properties of PagedResult:

var pagedInfo: PagedInfo? = nil
var hasMore = true
let query = TootNotificationParams(types: [.mention])

while hasMore {
  let page = try await client.getNotifications(params: query, pagedInfo)
  for notification in page.result {
    print(notification.id)
  }
  hasMore = page.hasPrevious
  pagedInfo = page.previousPage
}

⚠️ Different fediverse servers handle pagination differently and so there is no guarantee that hasPrevious or hasNext can correctly interpret the server response in all cases.

You can learn more about how pagination works for Fediverse servers using a Mastodon compatible API here.

In TootSDK it is possible to subscribe to some types of content with AsyncSequences, a concept we've wrapped up in our TootStream object.

for posts in try await client.data.stream(.home) {
    print(posts)
}

Underneath the hood, this uses our Paging mechanism. This means that when you ask the client to refresh that stream, it will deliver you new results, from after the ones you requested.

client.data.refresh(.home)

You can also pass an initial PagedInfo value to the stream call. For example, to start steaming all posts from the user's home timeline that are newer than post ID 100:

for posts in try await client.data.stream(.home, PagedInfo(minId: 100) {

Some timelines require associated query parameters to configure. Luckily these are associated values that their timeline enumeration require when creating - so you can't miss them!

for posts in try await client.data.stream(HashtagTimelineQuery(tag: "iOSDev") {
    print(posts)
}

• Register the app with the following scopes ["read", "write:accounts"].

• Get instance information and determine the sign up requirements. Some instances may not be open for registration while others may require additional verification.

let instance = try await client.getInstanceInfo()
if instance.registrations == false {
  // instance not open for registration
  return
}
// ...

• Use the registerAccount method to create a user account:

let params = RegisterAccountParams(
      username: name, email: email, password: password, agreement: true, locale: "en")
let token = try await client.registerAccount(params: params)