Leo Dion (host): Welcome to
another episode of Empower Apps.

I'm your host, Leo Dient.

Today I'm joined by Mark Schwieterman.

Mark, thank you so much
for coming on the show.

Mark Schwieterman (guest): you iOS.

Leo Dion (host): Yeah.

Before we get into daily and
what daily does, I'll let you

go ahead and introduce yourself.

Mark Schwieterman (guest): Sure.

So I've been in tech for a while
primarily did backend stuff and chemical

information industry for quite a while.

Grew up on Apple computers,
refocused on that around iOS two

or three or something like that.

And that's been my primary
focus in recent years.

I've been in a few different places and
been a daily for about six months now.

I just, I don't, I really love
working on video stuff and just

sort of communication technology
that helps people connect as we

all saw during the recent events.

Leo Dion (host): Yes.

I can imagine.

So you're working at
right now with daily.

You want to explain what daily
is exactly and what do they do?

Mark Schwieterman (guest): Sure.

So daily basically does pretty
much anything related to video.

So we're a real time video
infrastructure for developers.

We offer SDKs both for the
browser in the form of daily JS.

And then we have another daily
X library, which we use for

mobile SDKs, but for iOS,
Android react native flutter.

We also are just about to
release a Python library that

can be used for AI workflows.

We have.

Global mesh infrastructure.

So you don't have to deal with the
server side of things for your apps.

You can just get started and
start using things immediately.

In addition to that, we have a
little latency video streaming

options where you can actually
like composite different things

and stream those to an audience.

Both video and voice calls.

And we also satisfy a variety of
different compliance requirements,

such as SOC two and like a HIPAA
as an example for a telehealth.

Companies and things of that nature.

So if you have a problem,
we have a solution.

Leo Dion (host): Yeah.

And that's, it's a
growing thing right now.

No, is it mostly for like meetings
or conference calls essentially?

Mark Schwieterman (guest): So you
can really build whatever you want.

Our systems are built on WebRTC,
and we have a product also called

Prebuilt which is something that'll
give you like a call experience,

where you can have meetings with
other people and create rooms

breakout sessions and stuff like that.

But really we give you the tools to
build pretty much anything that you

want to related to video and streaming.

Leo Dion (host): Okay.

I'm asking if it's do you do anything
with like live streaming, Twitch

or YouTube or something like that?

Or is it mostly focused
on meetings between one or

more or two or more people?

Mark Schwieterman (guest):
We can support that too.

That is not my personal area of
expertise, but I believe there's

like RTMP and similar protocols
and we're compatible with those.

So like you could use our services
to do a similar broadcast as those.

And I'm not positive, but I believe
we can also forward things on

through other things too, but I would
actually have to double check on that.

Leo Dion (host): Yeah no, no problem.

No problem.

Cool.

Today we wanted to talk about you're
the head of the iOS SDK or maybe

do you do work on all the SDKs?

Mark Schwieterman (guest): So we
have like a client team and there's

two of us, myself and another
one of my team members who are

primarily focused on the iOS SDK.

But we do jump around like
we have a core layer that

we need to work on at times.

And so we just jump in wherever needed.

Leo Dion (host): Okay.

Okay.

So let's talk specifically
about the iOS SDK.

I looked at it I gotta say the
documentation is solid really good stuff

out there we'll get into that too, but
look what kind of makes what makes it

unique for Developing an SDK for iOS
specifically in this like video space.

Mark Schwieterman (guest): I would say
one thing that makes daily and our SDK

is unique is the team that we have here.

We just, we have a variety of people
that are very deep in different areas.

And so one of the features that we just
released in the SDK is adaptive HEVC.

And so typically with WebRTC by default
it uses VP8 and software encoding which

will actually run in your app process.

However with this, our adaptive HDVC
feature it will actually use the

hardware encoders on the device.

And that's also what lets us do H.

265, which will provide like
significantly better video quality.

With lower bandwidth and there's lots
of there's different characteristics

make it more optimal for delivery
and things of that nature.

So we have access to those lower level
like hardware features that you wouldn't

find with more, off the shelf solutions.

And we'll also we basically,
we like helping our Customers

solve their problems.

So if there's something that's like
possible and a customer is interested in

doing it, like we can usually find a way
to make that work for them and we'll add

features and such in support of that.

Leo Dion (host): So I want to, I'm
curious about the whole encoding space

as far as what you need to do most
of it is cause my understanding was

HEVC is only Apple, or is it like all?

All platforms support HEVC,
or how does that work?

And then when you're talking about
hardware encoding, I assume you mean

like the SOC, the A19 or whatever
the heck chip we're on, I forgot.

A17 is the new one, right?

Like those have encoders built
into the chip itself, correct?

Mark Schwieterman (guest): Yes.

Correct.

Yeah.

So this is very complicated and
there's lots of details, so I'm going

to make sure that I get everything
aligned right here, but so basically

with codecs, typically you have open
source versions of things and then

closed sourced similar to like how
with MP3s, there were open source

and closed source versions of that
provided by different companies.

So in the video space.

H two six four H two six five.

Those are not open source, but
then there are corresponding

versions of those.

And I'd probably get that wrong.

I'm almost certain that VP eight
is the open source version of

H two six four, but that may
not actually be the right one.

Leo Dion (host): Hehehehe.

Okay.

Mark Schwieterman (guest): As
far as interoperability goes

with web RTC browsers are
required to support basically.

VPH and H264.

So they have to support all of them.

So as long as you support
those, you have compatibility.

And then H265 is not actually supported
by most browsers that I am aware of.

And so basically when you stream
video, you can have multiple layers so

you can actually have like different
encodings, like all in the same

spree, same stream, more or less.

Leo Dion (host): Oh no,
I used the wrong word.

Mark Schwieterman (guest): I think
container is more of the file formats.

I'm not actually, yeah, I'm not
sure what the exact term would be.

But so as one example you
might you might publish three

different quality levels.

So if you think of an iOS app.

Like little thumbnails, you just
need low resolution because you

don't need 720 by 1280, right?

Which your phone can't
actually publish if you

Leo Dion (host): Yeah,
yeah, I know what you mean.

Yeah I, let's just say hypothetically
I've gone through and...

Run ffmpeg or youtube.

dl and it'll tell you all the
different streams you can get access

to so Yeah, I think that's what
you're getting at is you can get

like the you can get the webm or you
can get the h264 or whatever it is

Mark Schwieterman (guest): It exactly.

So we include basically two layers.

One that's H.

264 for compatibility.

So browsers and devices that
can't actually handle the H.

265 can then use that.

And, exactly.

And then for H.

265 and clients that support
it, it will then use that.

And so that allows us to have higher
quality video images, basically,

with less resource consumption.

And there's some other features.

There's this concept of
temporal scalability.

And so if you imagine I
believe it's every eight.

So there's imagine eight frames.

You can drop frames to decrease
the frame rate, which then also

reduces the bandwidth that's needed.

Leo Dion (host): Yeah,

Mark Schwieterman (guest):
So broad strokes, H.

264, H.

265.

As far as the encoding.

By default that'll happen in your app.

So if you were to profile it in
instruments or something, you

would see CPU usage and stuff like
that going on in your app process.

And then if you use the hardware
encoders, which are actually on Apple's

SoCs that'll actually go out and use the
hardware instead of your app process.

And if you profile those,
you'll see increased activity in

MedioserverD, which is the little
process on iOS that manages that.

So you're actually having your
video frames go over to that

process and be encoded before they
actually then get streamed out.

Leo Dion (host): Nice.

Nice.

So what, was there anything
new that came out as far as

with the Apple event recently?

And the new hardware?

Mark Schwieterman (guest): Yeah.

I haven't taught, had time
to dig into this in detail.

But I have seen basically the new
iPhone 15 pros and what is it?

The a 17 pro, I think the way
they're offset always trips me out.

But that supposedly actually
has an AV one decoder.

And so that's like
the successor After H.

265.

Also H.

265 HEVC are basically the same thing.

Leo Dion (host): Okay.

Okay.

Mark Schwieterman (guest):
use them interchangeably.

But so eventually we will have
hardware decoding support.

Now that's not something we
can use on the encoding side

yet, but it is interesting to
see, these things being added.

and so in the future, encoders,
then that's something else that we

could potentially start leveraging
to, to have even more options.

Leo Dion (host): Yeah.

Was there anything else you want
to talk about when it comes to

video encoding and decoding?

Or should we talk about the SDK stuff?

Mark Schwieterman (guest):
I think probably SDK.

Leo Dion (host): Alright,
let's get into it.

You guys deliver an
XC framework, correct?

First of all, let's explain what an
XC framework is to those who don't

know as far as a mode of delivering
a Swift package, so to speak.

Mark Schwieterman (guest): Sure.

So XC frameworks, SPM or at least
after SPM became more in use.

And so you can package up a binary
assets, XC framework being one of those,

and it lets you combine XC The platform
specific macho slices for different

PLA platforms all into one executable.

So you can basically distribute
a framework that you could then

use in iOS, mac, oss, or like
whatever platforms you need to

support, and you'll have one slice
for each supportive platform in

that overall framework bundle.

So it's kinda like a
framework of frameworks.

Leo Dion (host): And
it's a binary, right?

Because Swift packages, people think
it's just the source code that you

import, but you're not doing that.

You're doing an actual binary.

What are the advantages of that?

Mark Schwieterman (guest):
Let's see here.

I think for one that you
don't have to build it.

So it doesn't add your compilation time.

But for us it's basically a necessity.

Just because being dependent upon
WebRTC, that actually uses an

entirely different build system.

Leo Dion (host): Ah, okay.

Mark Schwieterman (guest): we couldn't
create a completely pure Swift SPM

package just because of some of
the dependencies that we have to

use to build the overall framework.

Leo Dion (host): Okay,
that makes total sense.

What was the the new kind of
library that you can build?

I'm losing it now.

It's not dynamic, and it's not
static, but it's the one in between.

They

Mark Schwieterman (guest):
Oh, the new ones.

Yeah.

Yeah.

And I was 60.

Oh, I forget.

I forget what it's called too.

But yeah, I know what
you're talking about.

Yeah, so there's the basically it
can be either one more or less.

Leo Dion (host): Have you
looked into that at all?

Or is it, is Web, is WebRTC, is
that like C or what is it exactly?

Mark Schwieterman (guest): C and.

Leo Dion (host): Okay.

Mark Schwieterman (guest): WebRTC
is developed and maintained by

Google and then the bulk of that is
written in C for kind of like the

core layers of it but then there
are also platform specific SDKs.

So for iOS, then there's
additionally Objective C

Leo Dion (host): Okay.

Mark Schwieterman (guest): of that.

Leo Dion (host): Okay.

Okay.

Yeah.

What's it called?

It's called mergeable libraries.

Mark Schwieterman (guest):
Mergeable libraries.

Yes.

Yeah.

I'm so

Leo Dion (host): go ahead.

Mark Schwieterman (guest): go ahead.

Leo Dion (host): I was just
going to say, I know they added

support for C plus this year.

Mark Schwieterman (guest):
I've seen that.

I've not had a chance to dig into
that yet, but that's something

that I'm very interested in.

Just because you work with WebRTC
and you can use a lot of the

classes, but sometimes you need
to customize their behavior.

But you potentially still need
to be able to like, call C code.

And there, there's some cases
where we've started building like

our own sort of replacement for
some of those standard types.

Leo Dion (host): Oh, okay.

Mark Schwieterman (guest): needed that
yet, but I can see that being useful.

And then you have the benefit of the
code you're working on is all Swift.

So you're not having to jump over
into other languages quite as often.

So

Leo Dion (host): I had to do

Mark Schwieterman (guest):
very appealing to me.

Leo Dion (host): a while ago before
I had even a blog post about this,

was this like how to have Swift talk
to C and I ended up having to create

an Objective C interface in between
and it was a mess, so yeah that's a

Mark Schwieterman (guest):
That, that's my life.

We basically have a core layer that's
objective C plus, and we actually

have our, some of our core libraries
are rust and we have to call that,

which that's a whole nother thing we
could probably talk about for a while.

But.

Leo Dion (host): So let's talk
a little bit about the CI setup.

So you guys, I assume, I don't know
where your code is stored, but you're

using, how are you setting it up?

So that way your XE framework is built
and always tested and things like that.

Mark Schwieterman (guest): Sure.

We use GitHub and GitHub actions,
and currently we have some co

located runners basically, and
are actually in the process of

setting up some images just to make
the maintenance of that easier.

And actually, brief tangent, but
I noticed that you have something

named Bushel that seems like
it's potentially in this space.

We've been looking at Tartlet,
but I'm just curious is Bushel

intended to be a CI solution or

Leo Dion (host): No, it's not.

Tartlet is definitely
more of the CI solution.

I definitely want to look at, I've,
yeah, I've gone down that rabbit hole.

But no, Bushel is more to run on
device to test your app on device.

More so than a CI solution.

For now.

For now.

Mark Schwieterman (guest): So as
you probably know, there's like

license restrictions and stuff.

So you're only allowed to run like two,
two virtual machines, like per Mac iOS

license or something of that nature.

And at least so far from what I've
seen the hosted runners you can run

like two VMs, which works pretty nice.

So our build system effectively,
we trigger through GitHub actions.

But then we also have to build all
of our frameworks and we need to be

able to build all of The languages.

So it gets quite complicated.

We have some stuff that runs for
Android on other hosted runners.

And then for iOS stuff,
we run the core build.

And so basically we build the core
library which is both WebRTC and

media soup C plus and C languages.

Then we have the daily core
library, which is built in rust.

And that controls, that's like things
that we add on top of WebRTC basically

to provide additional feature.

And then obviously some of these
customizations like the adaptive

HTTPVC that we were talking about
earlier that for that we actually

had to modify WebRTC itself so we
have our own custom build of that.

And then to actually call into
Rust code from Swift, you can't.

So we use FFI and bindgen basically.

So we generate C bindings to our Rust
code and then call that from Swift.

Yeah, so there's the,

Leo Dion (host): Yeah, what,
I'm not familiar with FFI.

You want to explain a
little bit how that works?

Mark Schwieterman (guest): So
it's foreign function interface.

If you've ever used a dynamic language
like Ruby, you've probably seen this

where like you install certain gems
and it'll start compiling things.

And so that's the idea.

And so basically it works,
it's similar in concept to how

obviously message send works.

Leo Dion (host): A little bit.

Yeah.

Mark Schwieterman (guest): So you
have the self pointer and then like

a selector which kind of defines
the method that you're going to call

and then some number of arguments.

And so the way this works is you
basically generate C bindings

into, in this case, Rust
code and then to invoke that.

You have a pointer to that you pass
in, which is the thing that you're

actually going to invoke the method
on, and then additionally pass along

some arguments in some other format.

And so we have like a serialization
format, basically, where we give

it, we call, we have a pointer, and
then we have a payload that more or

less has all the stuff needed to do.

To make the actual method invocation.

So in CI, all that has to be
built from scratch and then

cleaned and then at the end of it
packaged up and into a framework.

So it's it can get pretty complicated.

Leo Dion (host): Yeah.

Yeah.

Yeah.

Yeah.

Okay, let's talk a little bit
more about the SDK and the iOS

SDK as far as what it provides.

So I deep dived into it.

It's really great.

Like you got a UI kit, everything's
UI kit and easy to plug in.

Where are things that as
far as SwiftUI is concerned?

Mark Schwieterman (guest):
So we do support Swift UI.

We have a demo app on GitHub
Iowa starter kit, and that is

written in Swift UI there are
not really native view there.

So have you had to use like
UI view representable UI view

controller representable in this?

Leo Dion (host): Yeah.

Yep.

Mark Schwieterman (guest): So that's
basically what we do currently is

we package up some of the WebRTC
related views inside of a Swift UI

view and then expose it that way.

Leo Dion (host): What are some of the
concerns folks should have if they're

going to start plugging this SDK?

What are some things they
should know off the bat that

they need to be aware of?

Mark Schwieterman (guest): For the
most part, things do just work.

It is a little bit different.

I would say the number one thing
with SwiftUI, and I'm sure you're

familiar with this But is, you
need to be conscious of changing

state in a way that can cause the
views to have to be re rendered.

Leo Dion (host): Okay.

Mark Schwieterman (guest): So what
we recommend basically our SDK is

very robust and we provide a lot of
functionality to do different things.

And it's often helpful to have
like your own domain layer.

And so you can transform things between
like the fuller at a high level we

have the concept of a call that you
would then join or leave and then

you have participants in the call.

And so that's like me whomever.

You don't want to be redrawing your
screen if like someone who's not

even going to talk un mutes something
or mutes it again because you're

not actually going to see that.

And you want to make sure that you
have things structured in a way that

is going to be effective for you and
that also gives you like a seam to

simplify things and then have you
used the SwiftUI Preview Canvas much?

Leo Dion (host): Yes.

Yep.

Mark Schwieterman (guest): Okay,
that is probably hands down

my favorite feature, period.

Leo Dion (host): Yeah

Mark Schwieterman (guest): Have
you been able to use SwiftUI

much in your own work personally?

Leo Dion (host): Yeah, I do
everything in SwiftUI right now.

Mark Schwieterman (guest): Okay.

Some of the companies I've
worked at, we've needed to

support UI kit and legacy apps.

And haven't really been able
to use Swift UI there much.

And I've gotten much deeper
in it and probably the past

a year and a half or so.

And it's the productivity benefits
of the preview canvas, different

devices, not having to build and
run a different screens and re

navigate like that is just amazing.

So that's why I mentioned
creating your own domain.

So like using our SDK with
SwiftUI, it will just work.

But there are huge benefits both to
thinking through like the performance

implications of like how you model
your own domain and additionally

structuring things so that you can
very easily create structs for use

in the preview canvas, just to do
your iterative UI development there.

Leo Dion (host): Yep,
that makes total sense.

Yeah, it reminds me we just did an
episode with Brandon Williams from

Point Free and he was talking about how

Mark Schwieterman (guest): Ah, love TCA.

Leo Dion (host): He keeps, keeping
stuff separate so that way you don't

have to worry about the video working
when you run the SwiftUI preview

or a simulator, for instance, and
that kind of sounds like what you're

talking about with the domain stuff.

It's exactly the same concept where
you try to keep stuff separated out.

Mark Schwieterman (guest): In fact,
like I, I am a huge fan of TCA wanted to

use it at a previous company, but just
couldn't do to like backward support.

I actually built something.

With Daily's Frameworks and TCA is
like one of the first things that I did

is just like a personal fun project.

The current starter kit that we
have it doesn't use TCA because I

didn't want to use any third party
dependencies just so that people

could, to make it more accessible.

Like you already know the stuff you need
to know for Apple development basically.

But I would very much
to port that to TCA.

The, it does a great job of solving
all of these sort of like problems

that SwiftUI doesn't really have an
out of the box solution to basically.

Leo Dion (host): right, yeah, exactly.

You, you obviously, if you're in
UI kit, you're gonna do a lot of

delegates and things like that.

Have you, how's that gone with
transitioning to using more like

publishers or async sequences or
combined or any of that stuff?

Mark Schwieterman (guest): Yes.

Mostly good.

Although I we did have
a learning experience.

So we support, I, I
believe back to iOS 13.

And Okay.

13, it might be 14.

I think we may have raised it to
14, but we also want to make sure

that, customers in any type of
business can use our framework.

And so depending on the type of company,
they may need to still support UI kit.

So we do have a delegate and for
UI kit apps, that's probably a

good way to go in some cases.

Additionally, we also
have published properties.

For some of the states or for
example, like call state is a

published property currently.

So our like participants we
have a big participant struct

and that gets published.

That can work good if you're doing like
an MVVM style UI kit app or in Swift UI.

But the one problem with that is
that you can't really create a

protocol for something that has
like a published property on it.

Yeah, so if you're wanting to provide
like I personally would love to

provide, like a first party test
double that people can use just so

they don't have to write their own
make that easier with published

properties, you can't use that.

One change that we plan on making soon
is basically switching from published

properties to explicit publishers for

Leo Dion (host): Oh, interesting.

Okay.

Okay.

Yeah what I've ended up doing is
just putting a protocol on the

thing inside the observed object.

And then having the observed object
just be whatever the class it's gonna

be in and the protocol's inside it.

And then the proper, the protocol
provides whatever you want to provide

to the published properties that way.

But, yeah.

Mark Schwieterman (guest): Oh like the
pro like the properties of the object

or value that would be published.

Leo Dion (host): Yeah, and then have
the protocol be like a different

implementation for simulator or for
whatever yeah, but that is, I've

heard that problem a lot with a lot
of people where they're like, I want

to use a published property and it's
we'll get into the new stuff, but yeah

Mark Schwieterman (guest): and that
is, yeah, obviously that, that is

really interesting because, that's
all going to be changing with iOS 17.

And I personally do you think
combine is here to stay?

Cause it seems.

Like some of it's going into
Swift packages, but I don't know.

Leo Dion (host): Or you
mean to like observation

Mark Schwieterman (guest):
so Combine itself, I think it

seems like it was introduced
initially in support of Swift UI.

Leo Dion (host): right,

Mark Schwieterman (guest): but then
the async await Swift concurrency

stuff seems to like largely be
superseding it, but there's that

there's a, I believe it's Swift async
algorithms package that you can use

and that like similar stuff that you
would have with combine publishers

is being added to that framework.

Leo Dion (host): So I'll be honest,
I haven't deep dived into, excuse me.

I haven't deep dived into
the async algorithms more.

I think the observation stuff
has really removed a lot of the

combined code that I've been doing.

In bushel, for instance,
I've talked about this.

Like I've, I have one piece of combine
right now in bushel, and that's

because it was something that I wrote
a year ago that I just am too lazy

to migrate over and it works great.

I think it's more of the observation
stuff has really made it.

Not necessary.

There's things I miss about it for
sure, but, and I like the functional

programming aspect and I think that's
what async algorithms provides.

But yeah, I, is it here
to, is it here to stay?

Probably not.

But it's not going to
go away anytime soon.

I would imagine.

Mark Schwieterman (guest):
I'm very conflicted.

Cause it took me a while
to warm up to combine.

It's just, it's a very different model.

And I feel like as soon as I started to
get my head around it Swift concurrency

came around and then, have you done
much with the async sequences and

Leo Dion (host): Yeah, I have not
done anything with async sequences.

That's where I, my, that's my blind
spot is is this like async sequences

and how that replaces combine.

I'm much more comfortable with async
08 when it comes to just the simple

Oh, this is an async call to a
network and you get back something.

But the async sequence stuff,
I'm still, I'll be honest.

They're like, I had to do something
with store kit recently and it was like.

Okay, I guess this is a for
loop, but yeah, it's weird.

Mark Schwieterman (guest): Yeah, and
just, yeah, like the sequencing and

there's stuff where like you basically
have to use a task group if you don't

want things to serialize and there's
just little things that at least

aren't always immediately intuitive.

I think it's really interesting for
SDKs though, because like, how do

you serve a bunch of customers that
have a variety of different needs?

Leo Dion (host): Yeah, you screwed,
honestly, in a lot of ways.

Yeah, cause it's oh, if you had to serve
somebody in iOS 14 and I still have

some apps like that, and it's yeah, good
luck trying to do any of that stuff.

Mark Schwieterman (guest): Where I've
settled on and so like we, we have,

and we'll continue to have a delegate.

I think we're going to replace the
published properties with publishers

and that way people that need them can
use them and then probably add in like

the async streams at some point, but you
can also get those off of publishers.

So they're interchangeable,
but not exactly.

Leo Dion (host): yeah, you gotta
serve everybody in every space.

I was gonna ask, like, how does
observation look to you as far as as

an alternative to published properties?

Cause I've got all in observation with

Mark Schwieterman (guest):
actually, yeah so I have

not used observation a ton.

I am very excited about
it for yeah for apps.

I'm very excited about it because what
I've seen, at least with Swift UI is

it's very non intuitive that changing
something non visible could cause

your entire view tree to re render.

And so I think that's gonna like
basically just solve a lot of that.

But I haven't used it enough.

Can you actually use observable
with to provide like a protocol

or for an interface that you
want someone else to use?

Have you tried anything like that yet?

Leo Dion (host): No, I haven't.

I'm so stuck on using it the
way observed objects are that I

haven't wrapped, I haven't put my
observed objects, or my, oh gosh,

I knew I was going to say that,
observation stuff in a protocol.

I still do it the old way where I have
a protocol inside the observed object.

No, I haven't.

I, you probably could?

I don't know.

It I would think it would
break the macro, but I could

totally be wrong on that.

I know I've had

Mark Schwieterman (guest): The whole
macro thing, like that, that just seems

Leo Dion (host): and SwiftData and
trying to use protocols in that space.

Macros are inter I love them, but
you gotta be careful because there's

stuff you can do with macros that'll
break them and you don't even know

until you like deep dive that, oh.

This modifies the code this way.

That's why it doesn't work.

So yeah.

It'd be interesting to see
if you can go that route.

Mark Schwieterman (guest):
That, that expansion feature

is just like magical to me.

Cause the property wrappers are just
opaque and it's we don't necessarily

know how these things work and just
being able to see like the actual code

Leo Dion (host): Yeah.

Yeah.

Yeah.

I think the biggest advantage of macros
is just now that we can see how some

of those stuff behind the scenes.

Works and we have access to it.

Like you said, property wrappers are
codable or any of that stuff that was

always like in the compiler that we
couldn't understand what was going on.

Now we can do that ourselves.

Which is awesome.

Mark Schwieterman (guest): So I
don't know that we'll be adopting

observation, at least on the API.

We'll probably do that like
publisher change that I mentioned

first, but my plan is basically
to update our starter, get app to

Leo Dion (host): Starter kit.

That's what I was going to say.

Yeah.

Yeah.

Yeah.

Cause

Mark Schwieterman (guest): yeah.

Leo Dion (host): I don't know
how to do this with opposite.

Yeah.

Okay.

Mark Schwieterman (guest): Exactly.

Yeah, I was hoping to do a
beta branch, but did not have

time to actually do that.

But now that, iOS 17 is about
to drop, it's about time.

So I'll probably be doing that soon.

And then I always like to try
something first and then take

what works and pull it up.

And so probably just use it directly
in the app and then figure out okay,

can we pull this back into the SDK
itself in a way that's helpful?

Or maybe the app is like the,
app layer is like the appropriate

place to use that, right?

Leo Dion (host): What were there any
other API APIs that were introduced

this year that you're like, this is
going to be awesome for us at daily?

Mark Schwieterman (guest): Yes.

Yes.

Some of which we can't actually use
yet, which is currently frustrating,

but I think I found something.

One thing that's really cool is, have
you used continuity camera at all?

Leo Dion (host): Not yet.

No

I know what it is.

It's like where you can use the
iPhone as a camera on a Mac or a TV.

Yeah.

Mark Schwieterman (guest):
E Exactly, yes, yeah.

There's there's actually like a third
party app named like Camo or something

which sort of provided a way to do this

Leo Dion (host): Yeah.

Mark Schwieterman (guest):
And continuity of cameras.

Kind of Apple's first
party version of that.

They're now bringing it to TVOS, which
for video conferencing stuff is really

cool because, you could just sit back
and have a conference on your Apple TV.

And then use your phone
as the camera for that.

And that totally works something
we can maybe come back to.

Although currently it's a bit more
difficult to actually get our framework

to work on tvOS due to the way it's
built and some of the Rust interactions.

Leo Dion (host): Oh, gotcha.

Okay.

Mark Schwieterman (guest): but
I think we have an approach

that will work with that.

So that is going to be really
cool once we get that working.

There's also the addition
of I think it's called UVC.

It's like a USB peripheral
device for iPad.

This is something else I want to
explore, but in some cases I think

it's helpful to be able to have a
video conference on an iPad and then be

able to have potentially like a camera
that is not your iPad, similar to how

you can do a continuity camera, but

Version of that.

There's new improved voice processing.

So for any of these things where,
you're worried about background

noise and stuff, that's just
going to automatically get better.

And then just as a fun thing I
was 17 is adding, like gesture

based reactions where it'll just
recognize gestures that you do on

screen and then do a visual effect.

Have you played with that at all?

Leo Dion (host): no, but I was just
thinking about the Apple event and

how we can do how we can do the double
tap, like all these little things that

we've gotten from what do you call it,
from the Vision Pro, like Apple's been

working on this stuff on the side and
they're just like here you go Here's

a little something for the iPhone.

You can guys can use.

Yeah, it's

Mark Schwieterman (guest): So funny
thing on that the watch double tap, I

saw that and I was like in awed and, I
looked at that and immediately I just,

I, in my head, I could see like the
vision pro, thing when they showed it

off and like the pinch gestures, right?

It turns out that was like
an existing accessibility

gesture on watch OS already,

Leo Dion (host): I just
released the podcast episode.

So we just talked about that.

Yeah.

Mark Schwieterman (guest): Okay,
so you got into that, on that.

Okay, I will check that out
then for the full backstory.

I just, I thought that was fascinating
because I was like, oh, this is cool.

Leo Dion (host): episode it was like
do they do all this with assistive

touch like yeah No, totally.

So

Oh I was gonna ask

Mark Schwieterman (guest): So good.

Leo Dion (host): Okay I they mentioned
this, they had a video about it.

I don't know if you saw this and I don't
know if you've you do anything with it,

but did you see like the rotating stand
thing that they added to the iPhone?

Mark Schwieterman (guest): Oh night
nightstand or stand something,

Leo Dion (host): There was a road.

There's a, they had a whole
WWDC video about this.

Okay.

I'm going to look it up.

Sorry.

But there's a new API, so you
can plug into a USB stand and.

Mark Schwieterman (guest): Oh yes.

Yeah, I did actually see that.

And it would let you, like remote
control it or something like that?

Leo Dion (host): Yeah.

What was that called?

Mark Schwieterman (guest):
I know the video.

I think Yeah so I've used a video
conferencing stuff before I worked

at one company remotely and they
would have like cameras in rooms

and you could control them.

So if you're trying to like
talk to someone, you could

like zoom in or zoom out.

And yeah, whatever that is,
they, they're, I believe

now adding support for that.

So I'm imagining like a little,
like a iPhone driven, like robot or

something that can like roam around
and then you can like control.

It's I would just be
something super fun.

Leo Dion (host): I'm trying to
look what, which one it was.

Oh, here it is.

Dot kit integrate
motorized iPhone stands

Mark Schwieterman (guest): That's it.

Leo Dion (host): Yeah.

Yeah.

Yeah.

So yeah, I thought that was interesting.

I don't think we've seen any
hardware about it yet, but.

Yeah

Mark Schwieterman (guest): one I saw.

And yeah, like I, I don't actually I
don't know, I guess I'd like to see

if I could get my hands on one of
those devices just to play with it.

Cause that seems, and you think
about the A lot of this like AI image

recognition stuff is getting really
good and in some cases you don't even

need to use third party things for that.

So like with iOS you know
how iPad has center stage?

Leo Dion (host): Yeah,

Mark Schwieterman (guest): And in the
Apple studio supply display as well

basically you can actually get like
the region of interest back from that.

So it'll give you like the rectangle,
like where faces are basically not so

long ago, you couldn't do that yourself,
basically you had to write your own

code, but just, be able to build like
an app or something that uses that.

And then we'll potentially use doc
kit or something to be like, oh,

we'll reorient towards a person
or something interesting that

we're trying to keep an eye on.

Leo Dion (host): Yeah, exactly.

Okay, let's step back, we'll
stop talking about the fun

stuff and we'll talk about the

Mark Schwieterman (guest): All right.

Leo Dion (host): So a lot of this,
I assume you have to run a lot

of this through AV Foundation.

How was that experience?

What were some curveballs that you
got that were just like wow, this is

not what I thought it was gonna be?

I've done a little bit with
AV foundation, but not a lot.

I want to, because it's super cool.

But what yeah, give me the low down on
what it's like doing that experience

Mark Schwieterman (guest): So
AV foundation is very capable.

I have played with it in the past.

I once actually made a.

A podcast app for basically
dropping markers like audio markers

where you might want to edit

Leo Dion (host): chapters.

Oh, okay.

Yeah.

Yeah.

Mark Schwieterman (guest): Yeah.

And you can do all this stuff.

I guess that was more core audio
feature, but I would consider

that part of that umbrella,
but you can do virtually.

Anything with it from like building
apps that actually process things

offline to doing things live there.

There's a lot going on there Basically
with web RTC specifically a lot of that

is handled for you, but you still have
to interact with it Which is strange

So the two main classes that you use
are AV audio session Which is a shared

global singleton and then like other
apps can also Make changes to that.

So that is one thing that's tricky.

So like when you want to do things
like choosing your audio device

you can use the system, I think
it's called MP volume view as one

example, you don't necessarily
have to write code to do that.

But in some cases, you actually do
want to and so as an example, if you

want to override to like always use
the speaker instead of an attached

device or something, then you have to
get in there and change that session.

So we have some code that provides
some management of that, but in some

cases like someone building an app
might want to manage that directly

too, and you still have to deal
with that, and you get notifications

on a route change, which means any
input or output device has changed.

Or if like the session is interrupted,
like imagine like you get a phone call

or something, the kind of things you
might get where like normally like

the audio might be ducked or something
like that just to be able to hear it.

And so dealing with that
is one point of complexity.

And then on the video side of things,
which is probably what I should have

started with, but you have a AV capture
device and that's your interface into

all of the cameras that you have.

And so WebRTC itself
supports that directly.

And so you can choose between
the cameras that you want to use.

So as one example, you could flip
between the camera facing you,

the user, or the camera on the
other side facing the environment.

And you need to switch between those
and working towards adding support

for like continuity camera on tvOS.

That's also like you need to use those
API is slightly different because you

have to deal with like reconnection and

Leo Dion (host): Ah

Mark Schwieterman (guest):
disappearing on you.

Leo Dion (host): okay.

Mark Schwieterman (guest): The biggest
curveball gotcha that I got, which it

was actually a learning moment for me.

It has to do with.

Video rotation, basically.

So you can just use WebRTC
out of the box and it handles

device rotation and all that.

Question.

Most of the apps you've worked on,
have they supported device rotation?

Leo Dion (host): probably not Honestly,

Mark Schwieterman (guest): Okay.

Okay.

On iPad in particular, that's something
that you need to deal with just because

Leo Dion (host): Yeah iPad, but
that was like over 10 years ago.

So yeah,

Mark Schwieterman (guest): Yeah,
something I've just through coincidence

of the things that I've worked on like
most of them have supported rotation.

So I'm just used to that.

And anyway, so this is the gotcha,
is WebRTC, all of that works fine

for local video if you use like the
video views that come with it and

everything rotates, but if you have
an app that doesn't rotate, there's

actually an issue with that because
it has to rotate the camera that

like the video that it's sending.

So that it's still like the right,
right direction on the receiver's

screen, but on the local device,
if the device doesn't rotate with

it, it will rotate it anyways.

And then it ends up being offset.

So to work around that there's
AV capture video preview layer.

And so that one you can actually use to
preview, the way that you would expect

and then let everything else rotate.

And that's this is actually something
that I'll be integrating into our

SDK shortly to handle that better.

Leo Dion (host): Cool.

As far as like networking stuff,
like actually sending the video out.

How does that work?

Mark Schwieterman (guest): We
do not have to write code to

do that really much at all.

WebRTC pretty much

Leo Dion (host): Does that work?

Okay.

Okay.

Mark Schwieterman (guest): Yeah, and you
basically you just give it the device

and the video frames get past WebRTC
and then based on the encodings that you

have configured things, it'll just be
streamed out and then On the receiving

side, like more or less of things will
be used, but frames can be dropped.

Like WebRTC itself is very resilient,
so it can handle packet loss.

And then there's a server
component called an SFU that also

participates in these interactions.

Leo Dion (host): All right,
let's jump into future plans.

What do you have as far
as support for other?

Obviously not watchOS, sorry.

I guess unless you're going to
show video and kill the battery,

I don't think you're going to
support watchOS anytime soon.

But as far as we talked about tvOS
did you want to expand on that at all?

Mark Schwieterman (guest): Yeah.

So this is where things
can get interesting.

So WebRTC being C plus you can
build it for lots of platforms and

Apple's platforms specifically.

However the platforms
have different behaviors.

And so WebRTC out of the box
has its own like conditional

compilation for Mac OS and UI kit.

Leo Dion (host): Okay.

Mark Schwieterman (guest):
So you probably know, I like,

like the coordinate spaces are
flipped as one example, there's

a variety of things that are
just like a little bit different.

Similar to that, you potentially
need to support other platforms too.

And with rust in the mix we also
need to have platform support there.

And so in order to build, the way that
Rust works is you you build on a certain

platform, and then you can also build
for certain targets, but they have

to be supported by Rust itself, and
they have different tiers of support.

The first tier is it just works,
but it doesn't support the standard

library, which quite often you need
if you're doing anything non trivial.

Tier two is then the standard
library should work, but it's

not like officially supported.

So the cur the current state of things
right there is basically Rust does now

have Tier 2 support for tvOS, and so it
is possible to build everything with the

standard toolchain and have that work.

However, it's not actually
shipped that way, so you have

to set up your own compiler.

Ha!

More or less, a nightly
build to get it working.

Vision OS, which I am
super excited about, is...

It's not yet supported by rust.

However have you heard of Mars uponify?

I think that was like maybe
Steve drones, Smith's project,

or there's a few of these

Leo Dion (host): Maurice
Cepan, the codename for

Catalyst a hundred years ago.

Yeah.

Mark Schwieterman (guest): yeah as
an example you have an arm 64 library

that you would run on a device and
previously, you couldn't run on

a Mac until max where I'm 64 too.

But then.

You could, but you still
couldn't because it wasn't

actually support, supported.

But there, there is actually a way
to go in and rewrite the macho slices

to basically like claim that it
supports a platform, that it doesn't.

And I've been trying to get that
working, but I think that might,

cause rest itself, like the
support is really quite similar.

And so there's not something
functionally different on a

lot of these, different chips
on different device types.

It's just more how
things are identified.

Leo Dion (host): Have you
applied for a developer lab?

Mark Schwieterman (guest): No,

Leo Dion (host): Okay.

I just thought I'd

Mark Schwieterman (guest): I
really want to, but I feel like

I need an app for that and have
not, you mean provision OS,

Leo Dion (host): yeah.

Mark Schwieterman (guest): Did you?

Leo Dion (host): Yeah.

No, no way.

No way.

No, I'm not flying to California.

Mark Schwieterman (guest): No.

Leo Dion (host): Sorry.

Mark Schwieterman (guest): I
think there's one in New York.

Leo Dion (host): I hope so.

It'd be nice.

Yeah.

Yeah.

Mark Schwieterman (guest): Yeah, in
an ideal world I want to try to get

this kind of rewriting the slices
approach working for tvOS and VisionOS.

As soon as I do that, I'm going to try
to port our app and then I don't know, I

guess it's maybe too late at this point.

But I would definitely like to take
advantage of that if I can find a

good scenario in which it makes sense.

Leo Dion (host): Anything else you
want to mention regarding daily or

future plans before we close out?

Mark Schwieterman (guest):
Just, if you're interested in

building apps check us out.

We have tons of resources
online, lots of educational

stuff about WebRTC generally.

And very interested in helping customers
build whatever they want to build.

Oh, also I guess we just, we're
just about to release this daily

Python SDK, which is really cool.

You can just drop this into
the various kind of like.

Like Jupyter notebook and things
of that nature that use Python just

like you just import it and you have
working like video stuff that you can

run, write in those things immediately
and you can use it to process a

video and audio to do transcription
and a variety of other things.

So really cool and worth
checking out, I think.

Leo Dion (host): Yeah.

If you're looking for really good
documentation, definitely take a

look at it, but you guys have done
a daily really impressive stuff.

Great starter kit that gets you going.

So definitely take a look at that.

Mark, thank you so much
for coming on the show.

I really appreciate it.

Mark Schwieterman (guest): All right.

Thanks for your time.

And I had a lot of fun Leo.

Thank you.

Leo Dion (host): Where can
people find you in daily online?

Mark Schwieterman (guest):
Daily is daily.

co and for me, I guess if you can
spell Schwedermann, just search for

Mark Schwedermann and I'm around.

I'm Mark is me on
GitHub, M A R C I S M E.

Leo Dion (host): Yep.

And we'll pull links to that in the
show notes in case people don't know

how to spell Swederman sch swederman.

People can find me on x I hate that.

At Leo g Dion, I'm a Mastodon at Leo G.

Dion at c Im.

My company is bright digit.

Take a look there.

There's some new articles
coming out about humane code

and CI and all sorts of stuff.

So thank you so much for
joining me for this episode.

If you're watching this on
YouTube, please and subscribe.

If you are listening to this on a
podcast player, I would love a review.

if there's something you want to talk
about or there's something you want

me to find a guest to talk about or
maybe me to talk about let me know.

I'd love to hear back.

Thank you again.

And I look forward to
talking to you again.

Bye everyone.