JCON 2020: Mobile Java Web Applications with MVC and OpenDDR

Mobile Java Web Applications with MVC and
OpenDDR
JCON2020#
www.jcon.one
Werner Keil
CATMedia
Our Partners 2020:

Agenda
 Introduction
 History and Comparison
 Project Overview
 MVC Frameworks
 Spring Mobile
 Jakarta MVC
 Demo
 Conclusion
#JCON2020 #OpenDDR #MVC 2

Who Am I?
 Consultant – Coach
 Creative Cosmopolitan
 Open Source Evangelist
 Software Architect
 Maintenance Lead – JSR 385
 Maintenance Lead – JSR 354
 Jakarta EE Specification Committee Member
 Author, Speaker
Twitter @wernerkeil

What is a DDR?

What is OpenDDR?
Day after day we all experience an incredible growth and fragmentation of devices
available on a more and more proliferated market.
Accurately tracking their specs has become very hard work.
But this complexity can be reduced if managed by a community daily involved in
improving the Device Description Repository (DDR).
This is the essence of the OpenDDR project, the best open and free repository of
device descriptions currently available.

Why is OpenDDR different?
If you want a comfortable user experience, you need dynamic, “responsive” content
according to hardware and browser of your device.
Device Description Repositories (DDR) are databases that plenty of information
concerning mobile phones, tablets, Interactive TVs, set top boxes and any device
having a Web browser. DDR allow developers to realize applications providing
appropriate user experience on each client
There are several DDR projects, most demand often hefty fees to access to their
databases and APIs or restricts free use to non-commercial applications.

JCON2020#
www.jcon.one
History
@wernerkeil

WURFL Wall

WURFL Wall since August 2011

WURFL no longer Open Source

Apache Trail
 In late 2011 a few months after OpenDDR started, Apache committers and
members got aware of the technology and its relevance. Deciding to create both a
unified Device Repository and APIs for Java and .NET.
 OpenDDR was a Founding Member of the Apache DeviceMap Incubator.
 It graduated in late 2014, but compared to OpenDDR with monthly release cycles,
that was not archived for long despite hopes that an Apache project would attract
more contributors, activity and releases decreased in the years after.
 So DeviceMap was retired in January 2017.

Back to the Roots
 About a year after the reboot under OpenDDR.mobi the project saw record-
breaking downloads of nearly 175,000 in July 2018 alone. With total of almost
500k in 2018.
 This continued with 6-digits in 2019 and despite COVID-19 also affecting top sites,
it should be 5-digit by the end of the year, more than DeviceMap ever had in its
lifespan between 2011 and 2016.

Project Comparison
Project Strength Weakness License
51Degrees.mobi More Predictable
product catalogue,
.NET Support
Free license contains fewer devices,
usually less accurate
Repository: MPL or Commercial
(„Pro Edition“)
API: Mozilla Public License
DeviceAtlas Data is multi-
sourced from
industry-leading
partners.
Some W3C
compliance
Only commercial licenses. Repository: Commercial license
API: Commercial license
WURFL Former Community
project
(till Aug 2011)
The license does not allow to use
the DDR without accessing through
the WURFL API
the API does not allow use in
projects with a proprietary license
Repository: Use not allowed if
accessed without WURFL APIs
API license: dual licensing AGPL
and commercial
(Changed since August 2011)
NetBiscuits Service based,
seems easy to
integrate at least
via JavaScript
Free and SME offerings dependent
on using their JavaScript , no API
below Enterprise or “OEM” price
range
Repository: N/A
Volantis Relatively wide
device coverage
Only commercial licenses.
Multiple takeovers, the last owner
did not show support for it any more.
Repository: Commercial license

JCON2020#
www.jcon.one
Project Overview
@wernerkeil

Why Open Standards?
 OpenDDR stakes on open standards:
• Repository is fully compliant with W3C DDR
• SimpleDDR library implements the W3C DDR Simple APIs
 From a developer point of view:
• You can start developing your application with confidence that your product will work with any
W3C DDR Simple API implementation, no binding to OpenDDR DDR implementation
• Adopting a W3C standard, the Copyright of these interfaces is
owned and protected by W3C against any IP or patent claim
 The Apache License means that you are free to use all of OpenDDR in open
source or proprietary software.

What's different in OpenDDR?
 Users can update the operating systems of their devices either with custom builds,
or just install a new browser.
 E.g. Google‘s Project Ara aimed for modular devices with an almost endless
combination of capabilities.
 The identification of a device through the original User Agent exposed by
manufactures is not always enough.
 OpenDDR considers the device as a combination of three important aspects:
Physical Device
Operating System
Web Browser

Level of Confidence
 OpenDDR can identify custom builds of the operating system and third party
browsers.
 If a particular version of a browser or an operating system is not recognized,
OpenDDR returns information about the closest version rather than not returning
any information at all.
 OpenDDR identifies a device, a web browser or an operating system with a
certain level of Confidence.
 You can specify the threshold as a target to achieve in the identification process.
The higher the confidence the slower or more memory consuming the process
may be.

Patching and Optimization
 Lowering the confidence speeds up
the process, even if you can have less accurate results.
 OpenDDR supports Patching the data source.
 In OpenDDR we can specify a reduced vocabulary in order to limit the memory load.
• It can be specified in the oddr.limited.vocabulary.path property of the OpenDDR properties file.
• It allows developers to choose which properties need to be loaded in memory at startup from
the datasource. In most case developers need only a subset of properties from the datasource.

Load Test
 We compared OpenDDR with WURFL API (1.3.1) in terms of memory load in two
situations:
Without limited vocabulary
With limited vocabulary
 We used jMeter as workload generator, configuring it in order to generate 100
requests per seconds from 10 workers with a different user agent. The user
agents set contained ten of most common user agent observed in a real
environment.
 Both OpenDDR DDR and WURFL API were tested in a simple web app.

Test Results
 We chose as limited vocabulary the W3C core vocabulary
 The memory load of OpenDDR with limited vocabulary is only about
50MB and after initialization, OpenDDR won't show a memory spike.
 Both APIs identified correctly all the user agents in the HTTP request

DDR Service Retrieval
To create the identification service we use the ServiceFactory
of W3C DDR-Simple-API
initializationProperties.load(context.getResourceAsStream
("/WEB-INF/oddr.properties"));
Service identificationService =
ServiceFactory.newService(“mobi.openddr.ssimple.DDRService",
initializationProperties.getProperty(DDRService.ODDR_VOCABULARY_IRI),
initializationProperties);
The first argument is the class implementing the DDRService;
the second argument is the default vocabulary used in the
identification if the vocabulary is not specified;
the third argument is the SimpleDDR properties file.

New Java Client
While departing from W3C compliance a new Java client offers
more flexibility e.g. when it comes to ways of loading
device data.
Data can be loaded via:
• URL
• JAR file
• File system
Get classifier from a URL:
Classifier cl = Classifier.builder().with(LoaderOption.URL,
"http://openddr.mobi/data/snapshot/");

New Java Client (2)
Get the client using JAR data source
Classifier cl = Classifier.builder().with(LoaderOption.JAR);
Get client using data from file system
Classifier cl = Classifier.builder().with(LoaderOption.FOLDER,
"/some/path/OpenDDR/latest/devicedata");
The last option is closest to the W3C DDR client.

Metro – OpenDDR for .NET
#JCON2020 #OpenDDR #MVC 28Foto: Melanie Zanin

OpenDDR
 Open, free, based on W3C standard. Update to DDR by the community and
device manufacturers.
 Identification is not only for the device as a single entity but extended to the web
browser
and the operating system. OpenDDR can identify third parties web browsers and
customized operating systems. A developer can specify the vocabulary and the
aspects of the property he wants to know.
 Easy migration: Device Repository and most OpenDDR APIs are compatible with
W3C DDR

JCON2020#
www.jcon.one
MVC Frameworks
@wernerkeil

Spring Mobile
Spring Mobile is a framework on top of Spring MVC that provides capabilities to
detect the type of device making a request to your Spring web site and serve
alternate views based on that device.
Features:
 A Device resolver abstraction for server-side detection of mobile and tablet
devices
 Site preference management that allows the user to indicate if he or she prefers a
“normal”, “mobile”, or “tablet” experience
 A site switcher capable of switching the user to the most appropriate site, either
mobile, tablet, or normal, based on his or her device and optionally indicated site
preference
 Device aware view management for organizing and managing different views for
specific devices#JCON2020 #OpenDDR #MVC 31

Device Detection
@Controller
public class HomeController {
private static final Logger logger =
LoggerFactory.getLogger(HomeController.class);
@RequestMapping("/")
public void home(Device device) {
if (device.isMobile()) {
logger.info("Hello mobile world!");
} else if (device.isTablet()) {
logger.info("Hello tablet world!");
} else {
logger.info("Hello desktop world!");
} }
}#JCON2020 #OpenDDR #MVC 32

Site Preference
@RequestMapping("/")
public String home(SitePreference sitePreference, Model model)
if (sitePreference == SitePreference.NORMAL) {
logger.info("Site preference is normal");
return "home";
} else if (sitePreference == SitePreference.MOBILE) {
logger.info("Site preference is mobile");
return "home-mobile";
} else if (sitePreference == SitePreference.TABLET) {
logger.info("Site preference is tablet");
return "home-tablet";
} else { logger.info("no site preference");
return "home"; }
}#JCON2020 #OpenDDR #MVC 33

Device aware View Resolution
@Bean
public LiteDeviceDelegatingViewResolver liteDeviceAwareViewResolve
InternalResourceViewResolver delegate =
new InternalResourceViewResolver();
delegate.setPrefix("/WEB-INF/views/");
delegate.setSuffix(".jsp");
LiteDeviceDelegatingViewResolver resolver =
new LiteDeviceDelegatingViewResolver(delegate);
resolver.setMobilePrefix("mobile/");
resolver.setTabletPrefix("tablet/");
return resolver;
}

Jakarta MVC
Model-View-Controller, or MVC, is a common pattern for Web frameworks, mostly to
build HTML applications. The model refers to the application’s data or domain object,
the view to the data presentation and the controller is responsible for managing input
and out models and producing output.
Web UI frameworks can be action-based or component-based.
The API defined by the Jakarta MVC specification falls into the action-based
category and is, therefore, not intended as a replacement for component-based
frameworks like JavaServer Faces (JSF), but as a different approach to build Web
applications on the Jakarta EE platform.

JCON2020#
www.jcon.one
Demo
@wernerkeil

Links
 OpenDDR Website:
http://openddr.mobi
 OpenDDR Sources and Data:
https://github.com/OpenDDRmobi
 Mailing List:
https://groups.google.com/g/openddr
 Jakarta MVC:
https://jakarta.ee/specifications/mvc/
 Spring Mobile:
https://projects.spring.io/spring-mobile/

Thank You !
JCON2020#
www.jcon.one
Our Partners 2020:

JCON 2020: Mobile Java Web Applications with MVC and OpenDDR

More Related Content

What's hot (20)

Similar to JCON 2020: Mobile Java Web Applications with MVC and OpenDDR (20)

More from Werner Keil (20)

Recently uploaded (20)

JCON 2020: Mobile Java Web Applications with MVC and OpenDDR