in ACTION!

The next generation application platform for business

Embarcadero
Reinvents Business
Application Development!
Pawel Glowacki
European Technical Lead for Delphi and RAD Studio
http://blogs.embarcadero.com/pawelglowacki
Agenda
0830-0900 Registrations
0900-0915 Embarcadero Overview
0915-0930 Introduction to AppWave
0930-1030 RAD Studio XE2 Overview
1030-1045 Coffee break
1045-1145 FireMonkey Deep Dive
1145-1215 Delphi 64-bit and VCL Styles
1215-1330 Lunch & coffee
1330-1400 LiveBindings Deep Dive
1400-1430 RAD Cloud Services
1430-1500 Q&A
Embarcadero Overview
Embarcadero provides
database professionals
and application developers
with award-winning software tools
to design, build and run their systems
in the environment they choose
Who is Embarcadero?
Developers, DBAs, and
Architects
Embarcadero Has You Covered
Introduction to AppWave
RAD Studio XE2
Overview
The ultimate application
development suite for Windows,
Macintosh, Mobile, and Web
Fast Native applications for Windows,
Macintosh, Web and Mobile
Write app once, compile
for multiple platforms
Data-rich, Component-based
Delphi and C++
native code performance
Delphi for 64-bit Windows
VCL Styles
RadPHP for full
visual web development
Introducing
Stunning HD and 3D
Business Applications
Native Power and Performance
Connect with any Data
and Services
Full Suite of UI Controls
Visualize Live Data
Styled Vector UIs
without coding
Communicate with Animations
No-Code Hardware Effects
The Next Generation Business Application Platform
Applications that Connect Everywhere
High-speed connectivity
to popular databases
Multi-tier applications
Clients on multiple
computers and devices
Connect to the world
of data, services,
and the cloud
Mobile choices for you and your users
Native mobile apps for DataSnap
iOS, Android, Blackberry,
and Windows Phone 7
Delphi and C++Builder DataSnap Servers
Mobile-optimized PHP web apps
Web apps that look great
Web apps that work great on mobile
devices
Package applications for distribution
Sell on Apple App Store and Android
Marketplace
And one more thing
Create native iOS apps
Use the RAD Studio XE2 IDE
Create a Delphi FireMonkey application
Compile for iOS
Run on iPhone, iPad, iPod Touch
Your rich app, your rich data, everywhere


Demonstrations

RAD Studio XE2
and more!
Delphi XE2







The fastest way to build native Windows, Mac and
iOS applications

New in Delphi XE2
64-bit Windows
development
Target Windows,
Mac, and iOS
Create visually
stunning applications
VCL Styles
Connect with more
data and services
New and updated tools
including Fast Report and
Documentation Insight
C++Builder XE2







Rapid visual C++ development environment
New in C++Builder XE2
Target both Windows
and Mac
Create visually
stunning applications
VCL styles
Connect with more
data and services
New and updated tools
including Fast Report
C++ audits and
metrics
RadPHP XE2







The fastest way to build applications for Web,
Facebook and mobile
New in RadPHP XE2
JQueryMobile visual,
component-based
development of mobile
optimized web pages
Create iOS and
Android applications
that you can sell on
the Apple and Android
app stores
Zend Framework
components for email,
feeds, Google docs
and more
Embarcadero Prism XE2







Pascal development for .NET and Mono
New in Prism XE2
All new Oxygene Compiler 5.0 from RemObjects
Inline errors in editor with details, ranges & notes
Live compiler errors in the code editor
Fix-It support for selected new errors
Language soft interfaces and duck typing
Anonymous interface implementation
Enhanced Oxidizer integration

RAD Studio XE2 Developer Toolbox
Quickly design and generate
reports with FastReport
Deploy high performance
database applications with
InterBase XE
Incorporate graphs and charts using
TeeChart (VCL & FireMonkey)
Document your Delphi code
with Documentation Insight
RAD Studio XE2 Developer Toolbox
Compare files with Beyond
Compare differ
Ensure high performance with
AQtime
Automate your build process
with FinalBuilder
Build Web applications with
IntraWeb
RAD Studio XE2 Developer Toolbox
Locate problems more quickly
with CodeSite logging
Add a professional look with glyFX
Icon Library
Use InstallAware to create
your software installers
Get a jump start on component-
based internet development with
IP*Works
RAD Studio XE2 Developer Toolbox
Create reports with
Rave Reports
Indy (Internet Direct) Internet
component suite for popular
internet protocols
Partner DVD available online with
even more free tools!
RAD Studio XE2 Editions for Every Developer
Starter (Delphi/C++Builder)
Professional
Enterprise
Ultimate
Architect
RAD Studio XE2
Deliver Fast Native Applications
on Windows, Mac, Web and Mobile
Speed Up Your Development Process with RAD
Create Visually Stunning and Interactive
Business Applications
Build Applications that Connect Everywhere
Break Free from Grids Visualize Live Data
The ultimate application development suite for Windows, Mac, mobile and Web
Coffee Break
FireMonkey Deep Dive
The Next Generation
of Business Application Development
Media and graphics Rich user experiences
Intuitive and interactive easy to learn
Simulated real world physics
Touch and motion interaction

Consumer Software Renaissance
Business/Industry Software Stuck in Past
90s Windows user experiences
Confined to mouse/keyboard interaction
Complex to learn - slow to use

Key Markets
ISVs / Packaged Software
Healthcare / Medical
Manufacturing
Financial Services
Telecommunications

Energy
Aviation & Automotive
BioSciences
Pharmaceuticals
Utilities


User Experience
VCL
MFC
UE Performance
U
E

R
i
c
h
n
e
s
s

Business SW
is stuck here
FireMonkey
Introducing FireMonkey!
FireMonkey
Rich Application Platform for Business
Native CPU and GPU performance
Built-in Enterprise Database connectivity
Windows, Mac, and iOS

FireMonkey is not
Managed RIA
HTML5/CSS3
Game
Engine
FireMonkey is
App Development Platform
Delphi
C++Builder
Windows
Mac OS
iOS
VCL and FireMonkey
Win Mac iOS
VCL
FM
Native CPU/GPU Application Platform
Compile natively to Windows, Mac, and iOS
Application, Database, and Animation are CPU powered
All UI, Graphics, and Effects are GPU powered

HD Forms
High performance GPU powered Scalable Vector Uis
Maximum resolution on any device
Hundreds of visual UI components
GPU based Style Engine to control UI look & feel
HUDs with transparencies and transition effects

3D Forms
GPU powered 3D Forms
Hardware based lighting, textures, and animation
3D Forms can contain HD UI elements and effects

Effects & Animation
50+ Photoshop-like GPU Effects
Simultaneous multiple effects without performance hit
Path based animation for all HD and 3D UI and graphics

FireMonkey Overview
Cross-platform
Modern themed/skinned UIs
Real-time image and animation effects
Direct2D, D3D, Quartz and OpenGL
Native Delphi and C++
100% Object Pascal Framework
FireMonkey technology
Mac
HD use Quartz
3D rendering on Mac is OpenGL
Windows
Direct2D for HD
Direct3D for 3D
FireMonkey use GDI+ for HD vector
forms/controls, when Direct2D is not
available
FireMonkey HD, 3D, and GPU
FireMonkey takes advantage of GPU whenever possible

HD Form can be rendered on a computer without a
GPU with a few restrictions:
No TViewport3D, No Shader based Filters

A 3D Form requires a GPU - performs sophisticated
transitions and manipulations of the user interface

in other words, a 3D form may be the best
choice for building a sophisticated HD user interface
FireMonkey Architecture
TFmxObject = class(TComponent)
Create, destroy and release object
Cloning, storing and loading object from a stream
Child object manipulations (add, remove, search)
Free notifications
Abstraction layer for tab order
Support for FireMonkey resources
Support for FireMonkey animations

IControl
Handles Focus, Mouse and Keyboard events
Implemented by TControl and TControl3D

FireMonkey Architecture
IRoot
Interface for top-level containers
Handles Focused, Captured, Active controls
Implemented by TCustomForm

IScene
Container interface for 2D objects
Implemented by TForm, TCustomLayer3D

IViewport3D
Container interface for 3D objects
Implemented by TForm3D, TViewport3D
FireMonkey Styles
FireMonkey Stylebook
Any object inherited from TBaseObject
Set StyleName to identify
Found using FindStyleResource method from parented object
Stored In / Loaded From a stream file

FireMonkey Styles
A collection of FireMonkey resource style
WPF type of implementation
Styles can be inherited, saved, loaded
Look and Feel style files for Win7, MacOS, iOS and custom
themes

FireMonkey Animation
Used to modify property values over time
Machine speed independent
Can be looped and / or reversed
Can follow a variety of time / value curves
Can be triggered by MouseOver, Focus,
Visibility, etc.
FireMonkey Effects / Filters
Can be applied to bitmaps
Can be applied to controls
Can be triggered by MouseOver, Focus,
Visibility, etc.
GPU shader based implementation

3D Programming
One object model to target multiple platforms
FM uses right-handed orientation in 3D
Hardware acceleration
Windows DirectX
MacOS OpenGL
iOS OpenGL ES
FireMonkey and Cross Platform
FM is a platform that supports
RTL
GUI
Database
Operating System
Compile / Run on all platforms we support *



* subset for mobile platforms
Fire Monkey - Demos
Your first FireMonkey App
Windows
Mac OS X
HD / 3D
GPU/Shaders
Summary
FireMonkey - The Next Generation Business
Application Platform
Fully harness the powerful GPU graphics hardware
Rapidly build visually spectacular applications
Invest in one platform and deploy to numerous OS-s
Delphi and C++ compiled, native executable
Fully programmable animations and effects

Your imagination is the only limit !!!

Go FIREMONKEY !!!

Live Bindings
Deep Dive
What is LiveBindings?


Provides a way for developers to create a
read/write link between components/objects
and their data in the the application.
LiveBindings Overview
Supported by FireMonkey and VCL
Based on relational expressions, called binding
expressions
Can be unidirectional or bidirectional
Can be used programmatically or visually
Is all about control objects and source object
LiveBinding Engine
Allow developers to create live binding in run-time between
components/objects at design-time.
The LiveBinding visual components use the engine:
TBindScope for bindings to components
TBindScopeDB for bindings to databases
TBindingsList for holding of binding lists
A number of conversion services in the box and allows to create
new conversion service
Automatic updates
Expressions are automatically re-evaluated when a variable (e.g.;
property) referenced by an expression has changed value.
Requires external notification
LiveBinding components
TBindScopeDB magic binding
Bind data from DataSet to components
Link to DB Field wizard create the expressions to bind the data from DataSet
to components

TBindScope non-dataset binding
Bind data between components/objects
Support single object or collection of objects

TBindingsList
Hold the binding lists
Manage the list of methods and output converters used by the expression
LiveBinding Scenario
CONTROL
TLabel
SOURCE
TField
LiveBinding
Engine
Control Expression
Text
Source Expression
DisplayName
Binding Expression Editor
64-bit and VCL Styles
Deep Dive
Delphi 64-bit
Whats the same?
Integer, Longint, Cardinal still 32bits
Int64, UInt64 still 64bits
UnicodeString, AnsiString, WideString
Exceptions
Runtime Library (RTL)
SysUtils, Classes, etc


Delphi 32 and 64-bit Type Sizes
Signed types Delphi/32 Delphi/64
ShortInt 1 byte
SmallInt 2 bytes
LongInt 4 bytes
Integer 4 bytes
Int64 8 bytes

Unsigned types Delphi/32 Delphi/64
Byte 1 byte
Word 2 bytes
LongWord 4 bytes
Cardinal 4 bytes
UInt64 8 bytes

Whats different?
NativeInt, NativeUint 64bits
Pointer (all pointers) 64bits
Dynamic Arrays 64bit indexing
Floating point math - Double
Delphi 32 and 64-bit Type Sizes
Signed types Delphi/32 Delphi/64
NativeInt 4 bytes 8 bytes

Unsigned types Delphi/32 Delphi/64
NativeUInt 4 bytes 8 bytes

Delphi 32 and 64-bit Pointer Types
Pointer types Delphi/32 Delphi/64
Pointer
String
Class instance
Class reference
Interface
AnsiString 4 bytes 8 bytes
WideString
UnicodeString
Procedure pointer
Dynamic array
PAnsiChar
PWideChar
PChar
The CPU Programming model
Instructions and Addresses
64 bit address space
Limited by physical hardware
Same core Intel instruction set
New REX prefix for 64bit instructions
RIP-relative addressing
Jumps relative +/- 2GB
16 byte stack alignments

Online resources
http://msdn.microsoft.com/en-us/magazine/cc300794.aspx
http://msdn.microsoft.com/en-us/library/7kcdt6fy.aspx
What does this mean for Delphi?
Dont panic!
Delphi 64-bit on Windows
Same Windows API
CreateWindowEx, PeekMessage, etc..
Same Delphi RTL
SysUtils, Classes, Generics.Collections, etc
Same VCL
Forms, Graphics, Controls, Menus, etc..


Category Identifier dcc32 dcc64
Compiler DCC defined defined
VER230 defined defined
Platform MSWINDOWS defined defined
WIN32 defined not defined
WIN64 not defined defined
CPU CPU386 defined not defined
CPUX86 defined not defined
CPUX64 not defined defined
Availability ASSEMBLER defined defined
UNICODE defined defined
Pre-Defined Conditionals
Delphi 64-bit on Windows some gotchas
SizeOf(Pointer) <> SizeOf(Integer)
Integer<->Pointer casts will break in 64bit
SizeOf(THandle) = SizeOf(Pointer)
All Handles = SizeOf(Pointer) (HWND, HDC, etc..).
All code in process must be 64bit
Must have 64bit versions of external non-Delphi libraries (DLLs)
One, and only one, calling convention
register, pascal, cdecl, stdcall are ignored.
safecall is still special
Old pointer math code may break
Works in 32 and 64bit: MyPtr := PByte(P) + 10;
TLists internal FList is now a TPointerList. Used to be a PPointerList.
Removing ^ should be sufficient to port from 32-bit to 64-bit.
Tag property is now a NativeInt (32-bit vs 64-bit)
Delphi 64-bit on Windows some gotchas
Inline Assembly
Cannot mix asm blocks with Pascal code
Only procedural level asm blocks supported
Stack must be 16-byte aligned at each call instruction
Define locals for temp storage
Do not modify the RSP stack pointer
New unified calling convention. First 4 parameters in registers,
RCX, RDX, R8, R9 (or XMM0-XMM3)
Exception unwinding
No change for pure Delphi code. Exceptions function identically.
Inline Assembly can cause exception unwinding to fail if not
properly written.
SHL/SHR 32-bit values (Integer et al) will only shift in 32-bit space.
64-bit values will of course shift in 64-bit space.
No Extended type in 64-bit. Use TExtendedRec80 if necessary (binary
files with Extendeds in them for instance)
Windows API gotchas
SetWindowLong / GetWindowLong should
be replaced by SetWindowLongPtr /
GetWindowLongPtr for GWLP_HINSTANCE,
GWLP_WNDPROC, etc as they return
pointers and handles.
Pointers passed to SetWindowLongPtr should
be type-casted to LONG_PTR and not to Integer
/ Longint.
SetWindowLong mapped to
SetWindowLongPtr in Windows.pas.
Calls to our declaration of SetWindowLong are
safe, as long as they are cast correctly.

Windows API gotchas (cont)
Use explicit casts to WPARAM and LPARAM
where appropriate.
Example: Passing pointers through
SendMessage SendMessage(hWnd,
WM_SETTEXT, 0,
LPARAM(@MyCharArray));
Use LRESULT to cast message
results
Example: Message.Result :=
LRESULT(Self);
Message cracker records
(TWMxxx) changed
Alignment changes and field-size
changes


What can I do today?
Find all Integer<->Pointer casts, including
Integer<->instance casts.
Check for Pointer size assumptions
Ensure external dependencies are also 64bit
Image/bitmap libraries
Hardware interfaces libraries
ActiveX controls
Consider rewriting Assembler in pure-Pascal
Better future portability (think ARM CPUs)
Rely more on algorithmic performance rather
than raw assembly performance.
Make sure you know what bit-size (32 vs 64)
youre shifting with SHL/SHR.
VCL
Whats New in the VCL?
64-bit
VCL Styles
VCL Styles
Themes in Delphi/C++Builder XE and
earlier
Only 1 "theme" supported (native Windows)
3rd party products required to change look of VCL
apps
Current skinning" products for Windows
common controls
Requiring hooking WndProc's
Intercepting control messages
Separate controls needed for "custom" controls
TCustomControl / TGraphicControl descendants

VCL Styles
Multiple styles provided/supported
Custom style file creation
Custom style classes
Pluggable style engine
Works with TWinControl and TGraphicControl
descendants
VCL Styles
TThemeServices replaced by TCustomStyleServices
Extends TThemeServices with more parts, states and methods
TStyleEngine
Processes control messages
Calls StyleServices to render parts
TStyleManager
Provides services such as
LoadFromFile
LoadFromResource
RegisterStyle
RegisterStyleClass - Associates file extension with Style class
SetStyle
Style selection
Style engine selection
Providing custom styles
Create style file (using provided style building tool)
Implement TCustomStyleServices descendant and render parts directly
What cant be styled?
TMainMenu/TPopupMenu (main menu bar is
styled, but not the pop-up parts)
Ribbon controls
OS dialogs

Project Options | Appearance

From this

To this!

VCL Style Designer
Typical Usage
Uses Vcl.Styles, Vcl.Themes;
TStyleManager.SetStyle(Ruby Red Graphite);
RTL
RTL
Whats new in the RTL?
64-bit for Windows!!!
MacOSX - No COM, No ActiveX. :)
Windows specifics has been mapped to MacOSX equivalents wherever
possible
TOSVersion
Architecture (32/64-bit), Platform (Win/Mac), Major, minor OS version, Service Pack info
TFormatSettings
replaces global format setting variables (that don't exist on MacOSX)
TZipFile - cross platform Zip support
SymLinks in IOUtils and SysUtils file handling routines
class function TFile.CreateSymLink(const Link, Target: string): Boolean;
TLoginCredentialService
Extensible framework agnostic login credential services with support for
callbacks (success, failure, etc)
TPoint, TRect, TSize - new methods and properties
TPointF, TRectF, TSizeF - floating point versions
TFormatSettings (SysUtils)
type
TFormatSettings = record // System.SysUtils

CurrencyString: string;
CurrencyFormat: Byte;
CurrencyDecimals: Byte;
DateSeparator: Char;
TimeSeparator: Char;
ListSeparator: Char;
ShortDateFormat: string;
LongDateFormat: string;
TimeAMString: string;
TimePMString: string;
ShortTimeFormat: string;
LongTimeFormat: string;
ShortMonthNames: array[1..12] of string;
LongMonthNames: array[1..12] of string;
ShortDayNames: array[1..7] of string;
LongDayNames: array[1..7] of string;
ThousandSeparator: Char;
DecimalSeparator: Char;
TwoDigitYearCenturyWindow: Word;

end;
TZipFile (System.Zip)
type
TZipFile = class
..
public

procedure Open(ZipFileName: string; OpenMode: TZipMode); overload;
procedure Open(ZipFileStream: TStream; OpenMode: TZipMode); overload;
procedure Close;
procedure Extract(FileName: string; Path: string = ''; CreateSubdirs: Boolean=True); overload;
procedure Extract(Index: Integer; Path: string = ''; CreateSubdirs: Boolean=True); overload;
procedure ExtractAll(Path: string = '');
procedure Read(Index: Integer; out Bytes: TBytes); overload;
procedure Read(FileName: string; out Stream: TStream); overload;
procedure Read(Index: Integer; out Stream: TStream); overload;
procedure Add(FileName: string; ArchiveFileName: string = '';
Compression: TZipCompression = zcDeflate); overload;

property FileCount: Integer read GetFileCount;
property FileNames: TArray<string> read GetFileNames;

end;

TLoginCredentialService
type
TLoginCredentialService = class sealed
public const
Default = '';
DefaultUsrPw = 'DefaultUsrPw'; // do not localize
DefaultUsrPwDm = 'DefaultUsrPwDm'; //do not localize

strict private class var
FLoginHandlers: TStringList;
strict private
class constructor Create;
class destructor Destroy;
class function IndexOfHandler(const Context: TLoginCredentialEvent): Integer;
public
class procedure RegisterLoginHandler(const Context: string; const HandlerEvent: TLoginCredentialEvent); static;
class procedure UnregisterLoginHandler(const Context: string; const HandlerEvent: TLoginCredentialEvent); static;

class function GetLoginCredentialEvent(const Context: string): TLoginCredentialEvent; static;
class function GetLoginCredentials(const Context: string; Sender: TObject; const Callback: TLoginEvent): Boolean; overload; static;
class function GetLoginCredentials(const Context: string; const Callback: TLoginFunc): Boolean; overload; static;
class function GetLoginCredentials(const Context: string; var Username, Password: string): Boolean; overload; static;
class function GetLoginCredentials(const Context: string; var Username, Password, Domain: string): Boolean; overload; static;
end;
TPointF (System.Types)
type
TPointF = record
X: Single;
Y: Single;
public
constructor Create(const P: TPointF); overload;
constructor Create(const X, Y: Single); overload;
constructor Create(P: TPoint); overload;
class operator Equal(const Lhs, Rhs: TPointF): Boolean;
class operator NotEqual(const Lhs, Rhs: TPointF): Boolean;
class operator Add(const Lhs, Rhs: TPointF): TPointF;
class operator Subtract(const Lhs, Rhs: TPointF): TPointF;
function Distance(const P2: TPointF): Double;
procedure SetLocation(const X, Y: Single); overload;
procedure SetLocation(const P: TPointF); overload;
procedure SetLocation(const P: TPoint); overload;

function Add(const Point: TPointF): TPointF; overload;
function Add(const Point: TPoint): TPointF; overload;
function Subtract(const Point: TPointF): TPointF; overload;
function Subtract(const Point: TPoint): TPointF; overload;
function IsZero: Boolean;
function Ceiling: TPoint;
function Truncate: TPoint;
function Round: TPoint;
end;
C++
Whats New in C++?
FireMonkey
Live Bindings
DataSnap
Extended RTTI
Audits and Metrics
Demos
Demos
32-bit/64-bit Stylish Fish Facts
C++ Stylish Fish Facts
Stylish Live Bindings Fish Facts
DataSnap and Cloud
Deep Dive
Agenda
RAD Cloud Overview
DBExpress
New Cloud API
Whats new in DataSnap

Cloud API
What is the Cloud API?

Delphi API for accessing cloud application services
from Amazon and Microsoft Azure.
Cloud API service support
Storage Azure Blobs Service Amazon S3
Table Azure Table Service SimpleDB
Queue Azure Queue Service Amazon SQS
Name conventions
Amazon and Microsoft use different names for
the same things

Container = Bucket
Blobs = Object
Page = Multipart
ACL = ACL (Access Control List)
Microsoft Azure
Blob Storage
Unstructured storage
Defined Container
For storing large pieces of data such as: Images, Video,
Documents, etc.
Azure Tables
Scalable structured storage
NOSQL type tables
Entities stored in a table
Different set of properties made up of different types
Queues
Persistent asynchronous messaging
Each message is up to 8kb long
Amazon WS
Simple Storage Service (S3)
Blob Storage
Unstructured storage
Defined Container
For storing large pieces of data such as: Images, Video, Documents,
etc.
SimpleDB - Tables
Scalable structured storage
NOSQL type tables
Entities stored in a table
Different set of properties made up of different types
Simple Queue Service (SQS)
Persistent asynchronous messaging
Each message is up to 64kb long
Deploying to the Cloud
Deployment manager supports:
Microsoft Azure
Amazon EC2

What's new in DataSnap
Whats new in DataSnap
Enhancements
Server
REST Interfaces
Callback
Authentication Manager
New DataSnap Monitoring and Control
Server
Proxy info support for DataSnap HTTP
connections in TSQLConnection and
TDSRESTConnection
New TDBXChannelInfo.DBXClientInfo
(TDBXClientInfo record) provides:
IP Address
Protocol
Application Name (when possible) only for HTTP

HTTPS Support
For Stand-alone DataSnap servers
For Stand-alone WebBroker servers
DataSnap Wizards updated with HTTPS
support
Session Manager
Session support for TCP/IP protocol
Support for store and retrieve TObject in
Sessions
Sessions created and destroyed with the
TCP/IP protocol now notifies the
AddSessionEvent and RemoveSessionEvent
Support for multiple Callback Tunnels on
DataSnap REST Interface

Callback Tunnel Manager
TDSCallbackTunnelManager class in DSServer
unit
Allows tracking when:
Callback is added or removed
Tunnel is created or closed


Callbacks
Heavyweight callbacks now support
broadcasting to specific callbacks
GetAllChannelNames added to the DSServer
to get the name of all callback channels

Callback client side events
Notifications whenever the managers tunnel
is opened or closed, or when callbacks are
added to it or removed from it. Available for:
Delphi DBX Client Events
Delphi REST Client Events
JavaScript REST Client Events
Delphi DBX Client Events
TDSClientCallbackChannelManager
component, event OnChannelStateChange
Method signature:
(Sender: TObject; const EventItem: TDSClientChannelEventItem);

TunnelClosedByServer event type for
connections closed by the server or
connection loss.
Delphi REST Client Events
TDSRestClientChannel component, event
OnChannelStateChange
Method signature:
(Sender: TObject; const EventItem: TDSRESTChannelEventItem);

ChannelClosedByServer event type for abrupt
connection loss with the server
JavaScript Client Events
Set an event function to be invoked when changes happen
to the channel or one of its callbacks

var channel = new ClientChannel (clientID, channelName);
channel.onChannelStateChange = HandleChannelEvent;

If the server gracefully closes the channel, then the client
gets an event type of
ClientChannel .EVENT_CHANNEL_STOP

If the connection is abruptly lost, client will get an event
type of ClientChannel. EVENT_SERVER_DISCONNECT.
JavaScript session Support
initSessionData function (in
serverFunctionExecutor.js) now optionally
takes a second parameter.
The parameter will be prefixed to the general
cookie ID (dssessionid).
Allows you to have complete control over
which application uses which session
ID/cookie.

JSON results and REST calls
OnResult event has been added to the
TDSHTTPWebDispatcher and TDSHTTPService
components
Allow to change the JSON result format in
REST calls.
Method signature:
(Sender: TObject; var ResultVal: TJSONValue;
const Command: TDBXCommand; var Handled:
Boolean);

Query parameters in REST calls
GetInvocationMetadata().QueryParams

Returns a TStrings which holds a key value
pairs for all of the query parameters passed in
through the URL of the REST call
DataSnap Monitoring and
Control
DataSnap Monitoring and Control

DataSnap servers in XE2 are able to easily
monitor connections, and close any TCP
connection they wish.
What you can do
Take control over the client connections
Monitor client requests
Limit the number of requests per connection
Improve Security
More
How it works?
TDSTCPServerTransport components has two
new events:
onConnect
onDisconnect
Connections are linked with a Session ID
Listening to TCP/IP events
Detecting Graceless Disconnects
By default, the OnDisconnect event will not be
notified if the client abruptly loses his internet
connection
This behavior depends on OS configuration
Use TDSTCPChannel methods to control this
behavior for each connection:
EnableKeepAlive
DisableKeepAlive
How to use EnableKeepAlive
If the connection is idle for 10 seconds, then
send a keep-alive packet to check if the client
is still there.

Event.Channel.EnableKeepAlive(10000);
How to use EnableKeepAlive
If the client doesnt respond the OS will
resend the packet X number of times (Win 7
will retry 10 times).

You can specify the number of milliseconds to
wait between retries if a client doesn't
respond to a packet.

Event.Channel.EnableKeepAlive(10000, 100);
KeepAlive Enablement
Available through TDSTCPServerTransport
component
Three new published properties
KeepAliveEnablement - (Set: Default, Enabled,
Disabled)
KeepAliveTime - Integer Milliseconds value
KeepAliveInterval - Integer Milliseconds value

How to use DisableKeepAlive
Get the associated Channel for the given
connection and call:
DisableKeepAlive;
Closing Client Connections
Connection can be closed any time
Channel provide the connection instance

//Get the associated Channel for the given connection, and if successful close it
if FConnections.TryGetValue(Connection, Channel) then
Channel.Close;
Demo
Tracking all the TCP/IP connections and their
corresponding sessions
How to manually close a TCP/IP connection
from the server
How to detect when a client has lost internet
connectivity while connected.
Mobile and Connectors
Deep Dive
Mobile Connectors for DataSnap
DataSnap Mobile Connectors
iOS Objective C
Android Java
BlackBerry Java
Windows Phone 7 C#, Prism
DataSnap Mobile Connectors Demonstration
RadPHP XE2 Mobile App
RadPHP XE2 Phone Gap
Tools | Wizard for PhoneGap
Summary
FireMonkey - The Next Generation Business
Application Platform
Fully harness the powerful GPU graphics hardware
Rapidly build visually spectacular applications
Invest in one platform and deploy to numerous OS-s
Delphi and C++ compiled, native executable
Fully programmable animations and effects

Your imagination is the only limit !!!

Go FIREMONKEY !!!

RAD Studio XE2
Deliver Fast Native Applications
on Windows, Mac, Web and Mobile
Speed Up Your Development Process with RAD
Create Visually Stunning and Interactive
Business Applications
Build Applications that Connect Everywhere
Break Free from Grids Visualize Live Data
The ultimate application development suite for Windows, Mac, mobile and Web