Xamarin.Mac Introduction

Xamarin.Mac Introduction

Miguel de Icaza, CTO [email protected]

January 10th 2013

Xamarin.Mac Overview

• Build Mac applications with C#– Use C# and .NET libraries on Mac– All that you love: • LINQ, Task Parallel Library, async• GC, type safety, generics, dynamic and more.

– Mac AppStore ready

• Native Applications– Use native APIs to deeply integrate with OSX

Xamarin.Mac Overview

2.2B devices reachable with C#

Xamarin.Mac at a Glance

Mono Runtime

Xamaric.MacLibraries

Mono Core Class Libraries

Tools and SDK

• Binder• Bundler• Linker• Packager

MonoDevelop IDE Xcode(UI Designer)

Cocoa Frameworks

System Libraries

Darwin OS

Xamarin.Mac Frameworks

• CoreGraphics• CoreImage• CoreText• CoreVideo

Graphics• ImageKit• ImageIO• OpenGL• PDFKit

• AppKit• CoreAnimation• CoreImage

User Interface• QCComposer• QuickLook• SceneKit• WebKit

• AVFoundation• AudioToolbox• AudioUnit

Audio and Video• CoreMidi• CoreMedia• OpenAL

• AddressBook• Bluetooth• CoreLocation• CoreServices

System Services• CoreWLan• ScriptingBridge• StoreKit

• CoreData• CoreFoundation• Darwin

Infrastructure

• Foundation• ObjCRuntime• Security

Lots shared with MonoTouch (iOS)



• AppKit• CoreAnimation• CoreGraphics• CoreImage







Infrastructure


How does Xamarin.Mac work?

• OSX Libraries Projected to C#– 1:1 mapping from OSX native APIs to C#

• Objective-C (80% of APIs)– Object system mapped– Supports subclassing and overriding

• C-based APIs (20% of APIs)– Exposed as C# classes/methods– No support for subclassing or overriding

The Basics



• AppKit• CoreAnimation• CoreImage







Infrastructure


Anatomy of a Xamarin.Mac AppNSDocument version

Application DelegateCalled with application events, among them “FinishedLaunching”

Info.plistApplication metadata, used by the OS(app name, requirements, doc type handlers, etc)

Main application menuInterface definition for your main menu

Implementation for your main windowCode to implement the features of yourDocument handler.

Main Window UI DefinitionUI for your Main Window, edited withXcode.

Results

Structure of your App

NSWindow

The toplevel window in your app

NSWindow.ContentView

An NSViews, hosts all content

NSViews – Powerful containers

• NSViews can contain other NSViews• NSViews can handle events• NSViews can paint themselves• NSViews can layout their nested NSViews• NSViews can be backed by a CALayer– CALayers are GPU accelerated

• NSView properties can be animated

NSWindow and nested NSViews

AppKit - Application Framework

• Pervasive use of Model View Controller– Unless you are writing a custom control– All logic goes into your controller class– Controller orchestrates work of views

• Goes beyond the standard offering– High-level NSDocument does the heavy lifting– Full Menu, Saving, Loading, multi-window support

Extending our first Window

Create + Initialize Object

Hook up some code, lambda

Subclass

My app in Action

Creating Beautiful Interfaces

• Launch Xcode to editXIB files.

• Activate side-by-side view

• Control-drag to sourcefile.

Connecting your code

Exposing the UI to Code

• Outlets– Allows you to reference an object from code– Control-drag to source pane, and give it a name

• Actions– Allows a method to be invoked as a response– Control drag to source pane, and give a name

• In C# land– Actions become partial methods in your class– Outlets become properties in your class

Implementing Actions and using Outlets

Running

Behind the Scenes

Events and Callbacks

• In the C# world we are used to objects broadcasting events. Like this:– var myControl = new SomeControl ();– myControl.Clicked += SaveFile;– myControl.FocusIn += MakeFontBold;– myControl.FocusOut += ResetFont;

MyControl

SaveFile

MakeFontBold

ResetFont

Apple’s Idiom

• Objects instead send interesting events to a “Delegate”. All messages are sent there.

var myControl = new SomeControl ()myControl.Delegate = new MyControlDelegate ()

myControlDelegate

class MyControlDelegate : ControlDelegate {

override Clicked () {…}override FocusIn () {…}override FocusOut () {…}

}

myControl

Xamarin.Mac and Delegates

• Both models are supported– You get to choose in a per-instance basis

• Apple Delegate pattern mapped to C# events– Internally, we create the Delegate class, map it to

your C# lambda/anonymous method/delegate

• One replaces the other

SHIPPING YOUR APP

Shipping Your App - Yourself

• App has full access to the system

• Applications are shipped as “bundles”– Directory with .app extension– Self-contained, with no external dependencies– Optionally: generate installer from IDE as well.

• MacOS recently enabled GateKeeper– This requires you to sign your app– Or apps wont start on modern systems1 (by default)

1. Technically any Mac running Mountain Lion (10.8.xx) or Lion 10.7.5 and newer

Shipping your App - AppStore

• Mac App Store– Must apply to Apple for developer program– Must sign application– Submit app for review

• App will be sandboxed

• IDE signs, packages and launches uploader

• See Xamarin’s docs for tutorial

MacOS X Sandbox

• Kernel enforced sandbox• Limits access to the system:– Limitations on file system access– Use special Open/Save dialog panels– Limits access to services, and some kernel APIs

Mac AppStore – Sandbox Configuration

Info.plist

Editing this file brings upthe metadata editor.

Use this editor to configureyour application requirementsfrom the sandbox.

Next Steps

Learn more at:- xamarin.com/ma

c- Docs.xamarin.co

m

Free trial:- xamarin.com/trial

April 14 – 17, Austin, TX

2 Days of Xamarin Technical Training & Certification

2 Conference days covering all things mobile

Keynotes by Nat, Miguel and Scott Hanselman

Call for speakers officially open & sponsorship information available at [email protected]

Deep Dive at Xamarin Evolve 2013

http://xamarin.com/mac

http://xamarin.com/mac

http://xamarin.com/trial

Pricing

• Free trial at xamarin.com/trial

• Professional: $399

• Enterprise: $999 per seat

• Enterprise Priority: $2,499 per seat

Resources• Xamarin’s Mac Resources:

– http://docs.xamarin.com/mac

• API documentation:– Installed on first use (Apple + Xamarin Docs)

• C# samples: https://github.com/xamarin/mac-samples

• Support Forum: http://forums.xamarin.com/categories/mac

• Apple Developer Portal: http://developer.apple.com/mac

• Xamarin’s Evolve conference: http://xamarin.com/evolve

https://github.com/xamarin/mac-samples



http://forums.xamarin.com/categories/mac



MORE INFORMATION

TouchDraw and iCircuit

• TouchDraw

• iCircuit

PROJECTIONS

Objective-C Projection to C#

• What we map:– Classes – Structures– Methods and Properties– Objective-C blocks– Public global fields– Notifications– Dictionaries– Core data types

• Follow the .NET Framework Design Guidelines

Projecting Classes and Structs

• Identical class names• Scoped by namespace

Example:NSWindow and NSURL

BecomeMonoMac.AppKit.NSWindowMonoMac.Foundation.NSUrl

Projecting Methods and Properties

• We rename methods to follow .NET FDG• Use C# overloading

Example:-(void) drawString:(NSString *) str atPoint:(CGPoint)pos-(void) drawString:(NSString *) str

Becomes:void DrawString (string str)void DrawString (string str, PointF position)

Projecting Blocks

• Blocks are Objective-C lambdas• They are mapped to C# delegates– Can be used with C# lambdas or methods

Example:(int)(^)(string msg, int flag)

Becomes:delegate int X (string msg, int flag)

Projecting Notifications

Regular Style/Objective-C Strongly Typed

• Notifications are posted as strings + Dictionary• We map those to strong types + EventArgs

Projecting NSDictionary Options

• Dictionaries are used to pass parameters• Loosely typed, hard to debug, hard to find

• We provide strongly typed classes• They implicitly convert to NSDictionary– With the right magic keys– With the correct types for parameters

AppKit – The Heart of Mac Apps

Technology

Xamarin.Mac Introduction