Bring the App Cloud to your Android Wear watch. The App Cloud provides a rich set of APIs and everything required to create stunning apps, even for your smart watch. Android Wear is a version of Google's Android operating system designed for smartwatches and other wearables. Leveraging the Salesforce Mobile SDK for Android, you just need a few lines of code to extend your business process to your smart watch. With speach recognition, you can even talk to Salesforce. Join us to learn about the architectural principles to connect Android Wear devices with Salesforce in a session that will be packed with tips about what works and what you should avoid.
This document provides an overview of Android Wear and how to develop apps for it. Some key points include:
- Android Wear allows developers to extend existing Android notifications and apps to smartwatches.
- Notifications on Android Wear can include additional content, voice input, and actions.
- Apps need to be designed for quick interactions with minimal taps or swipes on small screens.
- The Android Wear SDK allows communicating between phone and watch apps using APIs for nodes, messages, and shared data.
Android Wear 2.0 is a major update and contains a number of significant updates that will make it easier to build delightful experiences for wearables. In this session, I will provide an overview of new features such as Standalone apps, Material Design on Android Wear and some of the new UI components we're making available (such as Navigation Drawers and Action Drawers), as well as complications and complication data providers.
In this session, I will give an overview of Android Wear and how to integrate it in your product strategy. We will look at the underlying design principles and discuss a number of use cases for apps that connect to wearable devices. After that, we will take a look at some code examples and learn how to use the Android Wear SDK.
This document provides an overview of developing for Android Wear. It discusses using notifications as the primary way to extend functionality from handheld apps to wearables. Notifications can be customized with actions, voice input, and multiple pages of content. For more complex experiences, custom wearable apps can be built that run directly on the device. These apps have activity-based interfaces but require simpler designs optimized for small screens and brief interactions.
This document discusses Android Wear development. It provides an overview of Android Wear's features and capabilities including notifications, sending and syncing data between a handheld device and wearable. It describes using notifications to receive messages and react to them on the wearable. It also discusses developing a case study app called Draw Watch for Android Wear which allows drawing on the wearable. The document reviews various Android Wear APIs like the Message API and Data API and provides code samples for sending notifications, opening activities, and syncing data between devices.
This document contains information about Nanik Tolaram, an Android platform engineer and writer who teaches monthly Android workshops. It discusses Android Wear and how it allows communication between wearable devices and Android apps via notifications. The document also provides an overview of the Android Wear emulator and SDK and envisions future directions for extending Android to new devices and platforms.
With the introduction of Google's Android Wear, you are no longer restricted to just phones and tablets when it comes to developing great Android apps. You want notifications on your wrist? You got it. You want to run an app on your wrist? You got it. In this session, let me take you through the awesome new features of Android Wear and the tools required to start building the apps you want for Wear. We'll extend a current app with rich notifications and even create a brand new app from scratch live on stage that runs right on your Android Wear device. All demonstrations will be coded in C#, but will be applicable to any Android developer in any language.
This document contains a presentation on UI testing. It discusses topics such as the Q&A segment, test pyramid layers including UI tests, service tests, and unit tests. It provides examples of locating and interacting with elements, writing automated tests, using the REPL, common queries and actions, and best practices for UI testing. The presentation recommends focusing UI tests on verifying flows and interactions without looking at system functionality. It also discusses setting up a test project, taking screenshots, waiting for elements, and integrating tests with App Center.
This document provides an overview of Android Wear and how to develop apps for it. Some key points include:
- Android Wear allows developers to extend existing Android notifications and apps to smartwatches.
- Notifications on Android Wear can include additional content, voice input, and actions.
- Apps need to be designed for quick interactions with minimal taps or swipes on small screens.
- The Android Wear SDK allows communicating between phone and watch apps using APIs for nodes, messages, and shared data.
Android Wear 2.0 is a major update and contains a number of significant updates that will make it easier to build delightful experiences for wearables. In this session, I will provide an overview of new features such as Standalone apps, Material Design on Android Wear and some of the new UI components we're making available (such as Navigation Drawers and Action Drawers), as well as complications and complication data providers.
In this session, I will give an overview of Android Wear and how to integrate it in your product strategy. We will look at the underlying design principles and discuss a number of use cases for apps that connect to wearable devices. After that, we will take a look at some code examples and learn how to use the Android Wear SDK.
This document provides an overview of developing for Android Wear. It discusses using notifications as the primary way to extend functionality from handheld apps to wearables. Notifications can be customized with actions, voice input, and multiple pages of content. For more complex experiences, custom wearable apps can be built that run directly on the device. These apps have activity-based interfaces but require simpler designs optimized for small screens and brief interactions.
This document discusses Android Wear development. It provides an overview of Android Wear's features and capabilities including notifications, sending and syncing data between a handheld device and wearable. It describes using notifications to receive messages and react to them on the wearable. It also discusses developing a case study app called Draw Watch for Android Wear which allows drawing on the wearable. The document reviews various Android Wear APIs like the Message API and Data API and provides code samples for sending notifications, opening activities, and syncing data between devices.
This document contains information about Nanik Tolaram, an Android platform engineer and writer who teaches monthly Android workshops. It discusses Android Wear and how it allows communication between wearable devices and Android apps via notifications. The document also provides an overview of the Android Wear emulator and SDK and envisions future directions for extending Android to new devices and platforms.
With the introduction of Google's Android Wear, you are no longer restricted to just phones and tablets when it comes to developing great Android apps. You want notifications on your wrist? You got it. You want to run an app on your wrist? You got it. In this session, let me take you through the awesome new features of Android Wear and the tools required to start building the apps you want for Wear. We'll extend a current app with rich notifications and even create a brand new app from scratch live on stage that runs right on your Android Wear device. All demonstrations will be coded in C#, but will be applicable to any Android developer in any language.
This document contains a presentation on UI testing. It discusses topics such as the Q&A segment, test pyramid layers including UI tests, service tests, and unit tests. It provides examples of locating and interacting with elements, writing automated tests, using the REPL, common queries and actions, and best practices for UI testing. The presentation recommends focusing UI tests on verifying flows and interactions without looking at system functionality. It also discusses setting up a test project, taking screenshots, waiting for elements, and integrating tests with App Center.
This document provides an overview of developing the first Flash application for Android, including why to use Adobe AIR, how to access device features from Flash, and the development process using Flash Builder and debugging on devices. It compares ActionScript and Java syntax, demonstrates building a simple app, and addresses questions about the activity lifecycle, back button handling, and screen resolution detection.
Android workshop - 02. Glass development 101Johnny Sung
Glass development 101
All example sources are in Github:
Example 00: Hello, World
https://github.com/j796160836/GlassWorkshop-Exercise00_HelloWorld
Example 01: New Hello, World
https://github.com/j796160836/GlassWorkshop-Exercise01_NewHelloWorld
Example 02: MyVoiceCommand
https://github.com/j796160836/GlassWorkshop-Exercise02_MyVoiceCommand
Example 03: UseCardBuilder
https://github.com/j796160836/GlassWorkshop-Exercise03_CardBuilder
The unconventional devices for the Android video streamingMatteo Bonifazi
Streaming video is not just through Android smartphone and tablet.
The 2014 was the year where Chromecast reached its brightness, getting into 4 millions living rooms. The 2015 instead is the year of the Android TV, the Google way “to smart” the TV.
This talk we’ll give you an overview about the streaming in Android. Starting from video streaming on mobile devices, we will guide you into the evolution of the development through Chromecast up to Android TV.
Matteo Bonifazi and Alessandro Martellucci will be illustrating this talk with their experiences developing mobile television applications for the main Italian broadcaster providers.
This presentation discusses how to create Glassware using the Mirror API, the GDK, and HTML5, along with a discussion of Live Cards and Immersions.
Various demos are presented, and you will see a quadcopter launched, along with the code.
This document discusses integrating Google Glasses with SAP using the Mirror API and Google API ABAP Client. It describes the different types of cards that can be used like static, live, and immersion cards. It also provides an overview of the Mirror API and how to use OAuth2 for authentication. The Google API ABAP Client library allows accessing Google APIs from ABAP. Examples are given of reporting applications using this library to interface with the Mirror API and publish cards to Google Glasses.
Android - How To Create Push Notifications With Custom View?
Today, most Android applications are integrated with the option to send push notifications. Developers and app publishers consider this capability as one of the most important actions in maintaining the relationship with their users and the ability to motivate them into performing certain actions within the app. However, in most applications the display of push notification message is quite basic - a miniature version of the app icon, a title (most of the time it will be the app name), with a short description below it.
Push notification message can be much more interesting! One of the better examples for it, is the way in which Groupon send their push messages - big and seductive picture, with important details such as price and the amount of discount. They also display action buttons!
In this tutorial we will learn how to create a rich push notification message.
Integrating Push Notifications in your app
If your app doesn’t yet support in basic push notification, please refer to PushApps short tutorial:
https://wiki.pushapps.mobi/display/PUSHAPPS/Android+Getting+Started
This tutorial assumes you have completed the basic push notifications integration, and you are able to receive notifications to your device. We will take you step by step from this phase and show you how to code and design the notification.
Push Notification received event
After you register the device to PushApps with your private keys, we would like to “take control” over the push notification received event. We would like to perform certain actions and display our custom view. With PushApps it’s easy:
1. In you Application class (if you don’t have one, please create it) register to PushApps with your Google API Project Number and PushApps Token.
@Override
public void onCreate() {
super.onCreate();
// first we initialize the push manager, you can also initialize the
// PushManager in your main activity.
PushManager.init(getBaseContext(), GOOGLE_API_PROJECT_NUMBER, PUSHAPPS_APP_TOKEN);
PushManager.getInstance(getApplicationContext())
.setShouldStartIntentAsNewTask(false);
// these methods are both optional and used for the notification
// customization
PushManager.getInstance(getApplicationContext()).setShouldStackNotifications(true);
}
2. We want PushApps to notify us when a new push notification received to the device. For that, we need to implement the PushAppsMessageInterface.
@Override
public void onCreate() {
super.onCreate();
// first we initialize the push manager, you can also initialize the
// PushManager in your main activity.
PushManager.init(getBaseContext(), GOOGLE_API_PROJECT_NUMBER, PUSHAPPS_APP_TOKEN);
PushManager.getInstance(getApplicationContext()).setShouldStartIntentAsNewTask(false);
// these methods are both optional and us
What are Progressive Web Apps and should you build one? This presentation looks at the problems PWA is aiming to solve and shows you how to get started.
The document discusses the history and future of building web applications using components. It begins by explaining the traditional client-server model and then transitions to discussing newer approaches like REST APIs and single-page applications built with components. It covers topics like building custom elements, using frameworks like Polymer, and the growing capabilities of the web platform for creating reusable UI components. The overall message is that the web is moving towards a more component-based approach to building applications in order to improve developer productivity and user experience.
The document introduces the Vaadin framework for building web apps. It discusses Vaadin's focus on simplicity for both users and developers. The founder emphasizes that Vaadin aims to empower developers to build intuitive user interfaces that improve the user experience. Vaadin prioritizes developer productivity to allow developers to focus on creating great user interfaces. The brand represents delivering simplified development experiences and intuitive interfaces.
Android TV: Building apps with Google’s Leanback LibraryJoe Birch
Android TV apps can be built using the Leanback library which provides UI components for TV. Key elements include BrowseFragments to display browsable content, PlaybackActivities for media playback, and custom card views. Interaction uses focus-based navigation via the D-pad. Testing involves performing clicks and other actions on view IDs. Features like picture-in-picture and recording are supported. Open source resources are provided to learn more about developing for Android TV.
The document provides an introduction and overview of developing applications for Android Wear. It discusses various aspects of creating notifications, standalone apps, and utilizing voice commands on wearables. Key points covered include adding dependencies, creating basic notifications, customizing notifications for wearables, handling voice inputs, using activities as custom notifications, and adding support for built-in and custom voice commands. Code samples are provided throughout to demonstrate implementation. The document aims to help developers get started with the Android Wear SDK and understand best practices.
The document provides an introduction and overview of developing applications for Android Wear. It discusses various topics like notifications, standalone apps, voice commands, and interactions between handheld and wearable apps. Code snippets are provided to demonstrate how to create notifications, add custom actions, handle voice inputs, create paged and stacked notifications, and add voice commands to apps. Links are included to documentation and examples to help developers get started with the Android Wear SDK.
This document discusses developing apps for Android TV. It covers setting up the SDK and dependencies, adding support for TV in apps, using fragments like BrowseFragment and DetailFragment from the Leanback library, and creating recommendations and notifications. Common errors like incorrect SDK level and missing TV launcher category are also outlined. The design guidelines, quality checklist, and publishing process for Android TV apps are referenced.
1. Android N introduces multi-window mode which allows users to use multiple apps simultaneously by displaying them in split-screen or picture-in-picture modes.
2. Developers can configure their apps to support multi-window mode through settings like android:resizeableActivity and by handling configuration changes and lifecycle methods appropriately when an app is in a paused state but still visible.
3. Best practices for multi-window include designing first for the smallest screen size, handling all orientations, and ensuring activities work properly when launched by other apps in multi-window mode.
Google Wear OS watch faces and applications developmentOleksandr Stepanov
Google Wear OS, formerly Android Wear, is the platform for wearable devices, watches primarily. In this talk, I would like to present what kind of applications may be developed for this platform, how it differs from regular Android development, what are the limitations, pitfalls and caveats.
In the deck I plan to cover the next topics:
* Kinds of applications available
* API available on the watch itself
* API for communication with a connected phone
* Watch face development specifics
How to bring your app out from the dust on the web thanks to App Links and App Indexing API. How to acquire new users for you mobile app and to re-engage existing ones thanks to Google Search.
Being Epic: Best Practices for Android DevelopmentReto Meier
This document provides best practices for Android development. It discusses five "deadly sins" to avoid: sloth (being slow and unresponsive), gluttony (using system resources irresponsibly), hostility (fighting users), arrogance (fighting the system), and discrimination. It also discusses five "glorious virtues" to embrace: beauty (design), generosity (sharing), ubiquity (being everywhere), utility (being useful), and epicness (being legendary). It covers topics like performance, wake locks, navigation, preferences, undocumented APIs, screen sizes, analytics, background updates, location services, and more. The overall message is to create high-quality, useful apps that respect users and system resources.
This document provides an introduction to the Salesforce Mobile SDK for Android. It discusses how mobile device usage is growing significantly, with many users relying on multiple devices for both work and personal use. The Mobile SDK provides tools to accelerate native, hybrid, and HTML5 mobile app development on Android and iOS platforms. These tools include OAuth authentication, API wrappers, an app container, secure offline storage, and push notifications. A five minute example is provided showing how to use the Mobile SDK to create a basic Android app that integrates with the Salesforce platform through REST calls.
Salesforce Mobile architecture introductionDavid Scruggs
- The document discusses mobile architecture and strategies for building mobile apps. It provides examples of native, hybrid, and web app approaches.
- Key aspects of the Salesforce mobile platform are highlighted including accessing data from any source, adding social collaboration features, leveraging business logic, and using a single identity system.
- Examples are given of companies like AXA, Zimmer, and Critical Systems that built successful mobile apps using the Salesforce platform.
This document provides an overview of developing the first Flash application for Android, including why to use Adobe AIR, how to access device features from Flash, and the development process using Flash Builder and debugging on devices. It compares ActionScript and Java syntax, demonstrates building a simple app, and addresses questions about the activity lifecycle, back button handling, and screen resolution detection.
Android workshop - 02. Glass development 101Johnny Sung
Glass development 101
All example sources are in Github:
Example 00: Hello, World
https://github.com/j796160836/GlassWorkshop-Exercise00_HelloWorld
Example 01: New Hello, World
https://github.com/j796160836/GlassWorkshop-Exercise01_NewHelloWorld
Example 02: MyVoiceCommand
https://github.com/j796160836/GlassWorkshop-Exercise02_MyVoiceCommand
Example 03: UseCardBuilder
https://github.com/j796160836/GlassWorkshop-Exercise03_CardBuilder
The unconventional devices for the Android video streamingMatteo Bonifazi
Streaming video is not just through Android smartphone and tablet.
The 2014 was the year where Chromecast reached its brightness, getting into 4 millions living rooms. The 2015 instead is the year of the Android TV, the Google way “to smart” the TV.
This talk we’ll give you an overview about the streaming in Android. Starting from video streaming on mobile devices, we will guide you into the evolution of the development through Chromecast up to Android TV.
Matteo Bonifazi and Alessandro Martellucci will be illustrating this talk with their experiences developing mobile television applications for the main Italian broadcaster providers.
This presentation discusses how to create Glassware using the Mirror API, the GDK, and HTML5, along with a discussion of Live Cards and Immersions.
Various demos are presented, and you will see a quadcopter launched, along with the code.
This document discusses integrating Google Glasses with SAP using the Mirror API and Google API ABAP Client. It describes the different types of cards that can be used like static, live, and immersion cards. It also provides an overview of the Mirror API and how to use OAuth2 for authentication. The Google API ABAP Client library allows accessing Google APIs from ABAP. Examples are given of reporting applications using this library to interface with the Mirror API and publish cards to Google Glasses.
Android - How To Create Push Notifications With Custom View?
Today, most Android applications are integrated with the option to send push notifications. Developers and app publishers consider this capability as one of the most important actions in maintaining the relationship with their users and the ability to motivate them into performing certain actions within the app. However, in most applications the display of push notification message is quite basic - a miniature version of the app icon, a title (most of the time it will be the app name), with a short description below it.
Push notification message can be much more interesting! One of the better examples for it, is the way in which Groupon send their push messages - big and seductive picture, with important details such as price and the amount of discount. They also display action buttons!
In this tutorial we will learn how to create a rich push notification message.
Integrating Push Notifications in your app
If your app doesn’t yet support in basic push notification, please refer to PushApps short tutorial:
https://wiki.pushapps.mobi/display/PUSHAPPS/Android+Getting+Started
This tutorial assumes you have completed the basic push notifications integration, and you are able to receive notifications to your device. We will take you step by step from this phase and show you how to code and design the notification.
Push Notification received event
After you register the device to PushApps with your private keys, we would like to “take control” over the push notification received event. We would like to perform certain actions and display our custom view. With PushApps it’s easy:
1. In you Application class (if you don’t have one, please create it) register to PushApps with your Google API Project Number and PushApps Token.
@Override
public void onCreate() {
super.onCreate();
// first we initialize the push manager, you can also initialize the
// PushManager in your main activity.
PushManager.init(getBaseContext(), GOOGLE_API_PROJECT_NUMBER, PUSHAPPS_APP_TOKEN);
PushManager.getInstance(getApplicationContext())
.setShouldStartIntentAsNewTask(false);
// these methods are both optional and used for the notification
// customization
PushManager.getInstance(getApplicationContext()).setShouldStackNotifications(true);
}
2. We want PushApps to notify us when a new push notification received to the device. For that, we need to implement the PushAppsMessageInterface.
@Override
public void onCreate() {
super.onCreate();
// first we initialize the push manager, you can also initialize the
// PushManager in your main activity.
PushManager.init(getBaseContext(), GOOGLE_API_PROJECT_NUMBER, PUSHAPPS_APP_TOKEN);
PushManager.getInstance(getApplicationContext()).setShouldStartIntentAsNewTask(false);
// these methods are both optional and us
What are Progressive Web Apps and should you build one? This presentation looks at the problems PWA is aiming to solve and shows you how to get started.
The document discusses the history and future of building web applications using components. It begins by explaining the traditional client-server model and then transitions to discussing newer approaches like REST APIs and single-page applications built with components. It covers topics like building custom elements, using frameworks like Polymer, and the growing capabilities of the web platform for creating reusable UI components. The overall message is that the web is moving towards a more component-based approach to building applications in order to improve developer productivity and user experience.
The document introduces the Vaadin framework for building web apps. It discusses Vaadin's focus on simplicity for both users and developers. The founder emphasizes that Vaadin aims to empower developers to build intuitive user interfaces that improve the user experience. Vaadin prioritizes developer productivity to allow developers to focus on creating great user interfaces. The brand represents delivering simplified development experiences and intuitive interfaces.
Android TV: Building apps with Google’s Leanback LibraryJoe Birch
Android TV apps can be built using the Leanback library which provides UI components for TV. Key elements include BrowseFragments to display browsable content, PlaybackActivities for media playback, and custom card views. Interaction uses focus-based navigation via the D-pad. Testing involves performing clicks and other actions on view IDs. Features like picture-in-picture and recording are supported. Open source resources are provided to learn more about developing for Android TV.
The document provides an introduction and overview of developing applications for Android Wear. It discusses various aspects of creating notifications, standalone apps, and utilizing voice commands on wearables. Key points covered include adding dependencies, creating basic notifications, customizing notifications for wearables, handling voice inputs, using activities as custom notifications, and adding support for built-in and custom voice commands. Code samples are provided throughout to demonstrate implementation. The document aims to help developers get started with the Android Wear SDK and understand best practices.
The document provides an introduction and overview of developing applications for Android Wear. It discusses various topics like notifications, standalone apps, voice commands, and interactions between handheld and wearable apps. Code snippets are provided to demonstrate how to create notifications, add custom actions, handle voice inputs, create paged and stacked notifications, and add voice commands to apps. Links are included to documentation and examples to help developers get started with the Android Wear SDK.
This document discusses developing apps for Android TV. It covers setting up the SDK and dependencies, adding support for TV in apps, using fragments like BrowseFragment and DetailFragment from the Leanback library, and creating recommendations and notifications. Common errors like incorrect SDK level and missing TV launcher category are also outlined. The design guidelines, quality checklist, and publishing process for Android TV apps are referenced.
1. Android N introduces multi-window mode which allows users to use multiple apps simultaneously by displaying them in split-screen or picture-in-picture modes.
2. Developers can configure their apps to support multi-window mode through settings like android:resizeableActivity and by handling configuration changes and lifecycle methods appropriately when an app is in a paused state but still visible.
3. Best practices for multi-window include designing first for the smallest screen size, handling all orientations, and ensuring activities work properly when launched by other apps in multi-window mode.
Google Wear OS watch faces and applications developmentOleksandr Stepanov
Google Wear OS, formerly Android Wear, is the platform for wearable devices, watches primarily. In this talk, I would like to present what kind of applications may be developed for this platform, how it differs from regular Android development, what are the limitations, pitfalls and caveats.
In the deck I plan to cover the next topics:
* Kinds of applications available
* API available on the watch itself
* API for communication with a connected phone
* Watch face development specifics
How to bring your app out from the dust on the web thanks to App Links and App Indexing API. How to acquire new users for you mobile app and to re-engage existing ones thanks to Google Search.
Being Epic: Best Practices for Android DevelopmentReto Meier
This document provides best practices for Android development. It discusses five "deadly sins" to avoid: sloth (being slow and unresponsive), gluttony (using system resources irresponsibly), hostility (fighting users), arrogance (fighting the system), and discrimination. It also discusses five "glorious virtues" to embrace: beauty (design), generosity (sharing), ubiquity (being everywhere), utility (being useful), and epicness (being legendary). It covers topics like performance, wake locks, navigation, preferences, undocumented APIs, screen sizes, analytics, background updates, location services, and more. The overall message is to create high-quality, useful apps that respect users and system resources.
This document provides an introduction to the Salesforce Mobile SDK for Android. It discusses how mobile device usage is growing significantly, with many users relying on multiple devices for both work and personal use. The Mobile SDK provides tools to accelerate native, hybrid, and HTML5 mobile app development on Android and iOS platforms. These tools include OAuth authentication, API wrappers, an app container, secure offline storage, and push notifications. A five minute example is provided showing how to use the Mobile SDK to create a basic Android app that integrates with the Salesforce platform through REST calls.
Salesforce Mobile architecture introductionDavid Scruggs
- The document discusses mobile architecture and strategies for building mobile apps. It provides examples of native, hybrid, and web app approaches.
- Key aspects of the Salesforce mobile platform are highlighted including accessing data from any source, adding social collaboration features, leveraging business logic, and using a single identity system.
- Examples are given of companies like AXA, Zimmer, and Critical Systems that built successful mobile apps using the Salesforce platform.
CloudOps evening presentation from Salesforce.comAlistair Croll
Peter Coffee, VP and Head of Platform Research at Salesforce, discussed building business apps on the Force.com platform. Force.com provides developers with tools to build scalable apps faster and at lower costs compared to traditional platforms. It offers capabilities such as visual process design, business rules, social business processes, and real-time device interactions. Force.com also enables secure communities and social business through its security and sharing models.
The Service Cloud portfolio provides a number of wholly cloud-based applications designed specifically in mind to integrate with your enterprise and deliver a rich 360-degree customer profile. At its basic core, the Service Cloud Console is an Application Framework which can be leveraged to:
Present all relevant details in context in a single page presentation
Integrate with 3rd party applications
Connect with customers via telephony, Live Agent Web chat, and Knowledge integration
Push information to your users as your data changes
Watch this webinar to learn about the Service Cloud Integration toolkit as well as other declarative and programmatic options available to customize and get the most from the Service Cloud Console.
Key Takeaways
Learn how to integrate your legacy web applications with the Service Cloud Console
Learn how to personalize the user experience with screen pops, launching primary tabs and subtabs, and setting tab titles
Extend functionality with Visualforce and custom console components
Intended Audience
Force.com Developers, Technical Leads, Architects, Application Directors familiar with the Service Cloud, Visualforce and JavaScript
Salesforce.com Mobile Dev Week Chicago DUGTom Gersic
This document summarizes a presentation about Salesforce's mobile development options. It discusses how the mobile landscape is changing as more devices are used for both work and personal use. The Salesforce platform powers over 3 million apps and provides tools to easily build mobile apps that connect to customer data. Developers can choose between building mobile web apps with Touch, or native or hybrid apps using the Mobile SDK which provides services for offline data, push notifications, and more. Hands-on labs demonstrate creating Visualforce apps integrated with jQuery Mobile.
This document introduces Visualforce for building mobile applications. It discusses how device usage is shifting to mobile and users need simple, fast interfaces. It demonstrates using jQuery Mobile and JavaScript remoting to build responsive mobile apps that interface with Salesforce data. The Mobile SDK is presented as a tool to accelerate development of native, hybrid and HTML5 apps with features like OAuth, APIs, offline storage and push notifications. Debugging mobile apps is also briefly covered, along with new Visualforce components for mobile.
Creating HTML5 Applications with jQuery Mobile, Ruby and Database.comSalesforce Developers
This document discusses strategies for building mobile applications using Salesforce technologies. It presents the Mobile Chow Finder application built with the Force.com Mobile SDK, jQuery Mobile, Database.com, Ruby on Rails, and hosted on Heroku. The presentation compares native, HTML5, and hybrid mobile app approaches and demonstrates how to develop an HTML5 app leveraging these open source technologies to access Database.com data from a mobile interface.
Creating HTML5 Applications with jQuery Mobile, Ruby and Database.comSalesforce Developers
This document discusses strategies for building mobile applications using Salesforce technologies. It presents the Mobile Chow Finder application built with HTML5, jQuery Mobile, Database.com, Ruby on Rails, and hosted on Heroku. The presentation covers native vs. HTML5 vs. hybrid mobile development strategies, an overview of the Salesforce Mobile SDK, and a demonstration of building the sample application using the presented technologies.
The Spring '14 Release is chock-full of great updates for developers, such as the ability to perform DML operations in JavaScript and tons of API updates. Watch this webinar to discover new and upcoming Salesforce1 Platform features slated for this release including:
Visualforce Updates: Visualforce enhancements in Spring ’14 include Visualforce Remote Objects for performing DML operations in JavaScript without the need for an Apex Controller, historical trending capabilities with the Analytics API, support for report chart components, PageReference URI support anchors, and several new components.
Force.com Canvas: Force.com Canvas continues to add useful features like the ability to access a Canvas app in the Chatter Publisher and Feed, the ability to add a Canvas app to the Salesforce1 App Mobile Navigation, support for using events between a Canvas app and a Visualforce page, as well as a new debugging console.
API Updates: New features have been added to SOQL, SOSL, REST API, SOAP API, Bulk API, Metadata API and the Streaming API. Additionally, we have opened up the ability to use the Data.com APIs, and added a new Place Order API to integrate Salesforce order data into any web or mobile application.
Developer Console: New features have been added that let you search through all files for specific snippets in your organization, change look and feel settings on your console, along with several user-experience additions like context menus.
Apex Code: Spring ‘14 adds new classes, methods and interfaces. You can now access reports in Apex with the Analytics API and updates have been made to Chatter in Apex.
[MBF2] Plate-forme Salesforce par Peter ChittumBeMyApp
Présentation de la plate-forme Salesforce par Peter Chittum lors de la journée de lancement de la Mobile Banking Factory 2.
API :
https://developer.salesforce.com
Site de la Mobile Banking Factory 2 :
http://mobilebankingfactory2.bemyapp.com
This document discusses mobile architecture and strategies for building mobile apps on the Salesforce platform. It outlines how the platform provides access to data, social collaboration features, business logic, identity management, and enables building apps that run on any device. The platform offers a secure container and tools to rapidly create native, hybrid, or web apps. The document also explores different mobile app strategies and emphasizes thinking of mobile as a platform to enable reuse and sharing across app types.
Join us and see what the last year has brought for Canvas since becoming generally available, and learn what features are in store for Canvas for the coming year. Get an overview of building Canvas applications and hear from developers using Canvas for the enterprise.
Developing Offline-Capable Apps with the Salesforce Mobile SDK and SmartStoreSalesforce Developers
The document discusses developing offline-capable mobile apps using the Salesforce Mobile SDK and SmartStore. It provides an overview of the Salesforce Mobile SDK and SmartStore, including key terminology like soups and stores. It also demonstrates building a sample app with SmartStore that allows querying, inserting, updating and deleting encrypted offline data to sync later.
The new Salesforce Mobile SDK 3.2 release provides developers with tools and capabilities for building compelling mobile apps powered by customer data in Salesforce. These mobile apps allow customers to build a stronger relationship with a business, and enables employees to be more effective.
Join us to learn how Mobile SDK combined with Salesforce Platform makes mobile app development a breeze. Experience various advanced features such as secure offline storage & data sync, push notifications, etc., which allow developers to unlock the full potential of customer data and the mobile devices.
This document discusses how to build engaging apps with Lightning from Salesforce. It introduces Lightning App Builder for non-developers to build apps, Lightning Components as reusable building blocks, and AppExchange for Components as a marketplace for pre-built Lightning Components from partners. It also addresses how Visualforce works with Lightning and how customers can plan a transition to leverage the new Lightning technologies while maintaining existing Visualforce customizations.
Igor Androsov on Mobilizing Salesforce Data with 12 Factor App on HerokuIgor Androsov
Dreamforce16 Mobile Thater presentation on building Mobile apps Twelve-Factor App methodology. Demonstrate how to use of Salesforce, Swift 3, Xcode, Heroku REST API on Swagger & Node.
The document introduces the Salesforce Mobile SDK for iOS. It provides tools for building native, hybrid and HTML5 apps on iOS and Android platforms. These tools include OAuth2 for authentication, API wrappers to interact with Salesforce REST APIs, an app container to embed HTML5 apps and access device functionality, and secure offline storage. The document also discusses device usage trends, the REST architecture, and provides instructions for installing and using a sample mobile app built with the SDK.
The Salesforce Platform Mobile Services provides developers with tools to easily create mobile applications while leveraging existing skill sets like Visualforce, JavaScript and HTML. The open-source Salesforce Platform Mobile SDKs afford you the flexibility of building native, web and hybrid apps for iOS and Android. This webinar is the first in a series focusing on the new Mobile SDK 2.0 features and will demonstrate how the SDK to can empower your Visualforce pages to create hybrid applications - applications that can leverage native functionality even when written completely in HTML and JavaScript. Future webinars will focus on using the iOS and Android versions of the Mobile SDK.
Josh and Akhilesh show developers how to take features of Mobile Services, like the jQuery Mobile Pack, and convert them to hybrid applications using the Mobile SDK 2.0. Developers will also see some of the unique features of the Mobile SDK - including new components for building your mobile interface and the ability to store information offline securely on a mobile device.
Key Takeaways:
Learn how to leverage your existing Visualforce and JavaScript skills to build mobile apps
Use HTML and JavaScript to easily create and customize your mobile interface
Leverage the Mobile SDK 2.0 to create hybrid applications that provide mobile device functionality, like secure storage and access to camera, using Visualforce pages.
Build, Manage, and Deploy Mobile Apps Faster with App Cloud MobileSalesforce Developers
Want to build mobile apps faster with the new App Cloud Mobile? In this session, learn from Salesforce mobile development experts as they show you how to build, deploy and manage mobile applications using the Mobile SDK, Heroku, Lightning Components and the Salesforce1 mobile app.
In this exclusive webinar you'll learn about
- Developing apps for iOS, Android and Hybrid Mobile environments with App Cloud Mobile
- Using Heroku as Mobile Backend as a Service (MBaaS)
- Building and Deploying Mobile Apps with Salesforce1
Similar to See Androids Fighting: Connect Salesforce with Your Android Wear Watch (20)
Sample Gallery: Reference Code and Best Practices for Salesforce DevelopersSalesforce Developers
This document provides an overview of the Salesforce Sample Gallery, which contains sample applications, reference code, and best practices for Salesforce developers. It describes different types of sample apps, including recipe style apps with specific code examples and standalone apps that demonstrate features. The document also outlines upcoming updates to the gallery, such as adding new applications and retiring outdated ones. It promotes benefits like inspiration, learning open source code, and understanding development best practices.
Maximizing Salesforce Lightning Experience and Lightning Component PerformanceSalesforce Developers
The document discusses various factors that affect the performance of Lightning Experience and Lightning Component pages. It outlines six main factors: geographical and network latency, device and browser capabilities, Salesforce org configuration, page complexity, component architecture, and server processing. For each factor, it provides recommendations for how to measure and optimize performance, such as enabling the Salesforce Edge network, limiting the number of components on a page, using conditional rendering, and leveraging caching features. The overall message is that page load time in Lightning Experience is sensitive to these infrastructure, code, and configuration factors.
Last year was eventful for Salesforce Developers - we started with the launch of Lightning Web Components (LWC), open-sourced it, enabled local development, and ended the year by open-sourcing Base Lightning Components. In this webinar, we will explore exciting new developments within Base Components and we will show you how to use open-source Base Components to build engaging applications faster with local development.
In this session we will,
- Spin up a local development environment to build Lightning web components
- Use and customize the base components and recipes to build pages and apps quickly
- Explore the latest features of VS Code developer tooling while coding for a use case
Over the past two months, we’ve announced many new resources for developers at Dreamforce and TrailheaDX India. To learn all about them, watch this video, where we'll explore live demos showcasing the latest updates for Lightning Web Components (LWC), Einstein, Heroku, and a lot more on the Customer 360 Platform.
In this session we,
- Explore key highlights from TrailheaDX India
- Show live demos of generally available features
- Explain how you can benefit from these features
TrailheaDX (TDX) is coming to ‘namma’ Bengaluru in India on Dec 19th and 20th! TrailheaDX India is the conference for everyone who builds on and customises Salesforce — including admins, developers, architects, and partners. This event will have sessions, demos and fun for those just getting started with the platform, as well as for advanced admins, architects and developers.
You might have questions about the event - and to answer your questions Kavindra Patel, known as the father of the Indian Salesforce Community, joins Shashank Srivatsavaya, Head of APAC Developer Relations. Register for our exclusive webinar to:
- Get a sneak peek into exclusive sessions and activities
- Find out who you shouldn’t miss at TrailheaDX India
- Understand what comes with your #TDX19 registration
CodeLive: Build Lightning Web Components faster with Local DevelopmentSalesforce Developers
GitHub repo: https://github.com/satyasekharcvb/lwc-local-dev.git
With the release of a new beta version of Local Development, you can now build Lightning web components faster than ever before! You can now render changes, iterate rapidly, troubleshoot errors, and even connect with data from your org by spinning up a local development server on your machine.
In this session, we build Lightning web components in real time. The exciting new capabilities we showcase will enable you to be an even more productive developer.
In this CodeLive session we:
- Spin up a local development server from the CLI to rapidly edit and view components
- Observe how a rich error handling experience simplifies testing and debugging
- Learn how to proxy data from an org for more context and fine-tuned development
CodeLive: Converting Aura Components to Lightning Web ComponentsSalesforce Developers
This document provides information about a Salesforce webinar on converting Aura components to Lightning Web Components (LWC). The webinar will feature two presenters demonstrating how to convert Aura components to LWC. The document includes forward-looking statements and disclaimers about product availability. It also provides information on asking questions during the webinar and resources for continuing the learning journey with Trailhead and the Trailblazer community.
Earlier this year, we released Lightning Web Components (LWC), a new UI framework based on web standards and optimized for performance and developer productivity. We have now open sourced the Lightning Web Components framework so that anyone can build applications on any platform.
Join our webinar where we'll explore how this framework, based on standard HTML, modern JavaScript (ES6+), and the best of native Web Components, helps you create web components and apps using the stack and tools you prefer.
We recently announced over 300 new features and enhancements at TrailheaDX '19 and for the Summer '19 release. In our Developer Highlights webinar we explore the top features with in-depth demos, including the latest updates for Lightning Web Components (LWC), LWC Open Source, CLI updates, Change Data Capture for external objects, Asynchronous Apex Triggers, Notification Builder and more.
Watch the recording here: https://youtu.be/kmOkk74QiCo
You can watch a recording of the live coding session at https://sforce.co/2IbU3yJ
In the fifth and final webinar of our five part series, we learn how to build Lightning web components for different use cases. We explore how to leverage all of the concepts you’ve learned in this webinar series to create modern apps with Lightning Web Components. We also demonstrate various ways to migrate Aura components to Lightning web components for a seamless transition.
This document discusses Lightning Web Components security and testing. It begins with forward-looking statements and risks related to new functionality, products, and services. It then provides information on debugging code, including using browser tools and debugging in different modes. Finally, it discusses unit testing Lightning Web Components with Jest, including prerequisites, configuration, and an example test file.
LWC Episode 3- Component Communication and Aura InteroperabilitySalesforce Developers
Lightning Web Components gives JavaScript developers a web standards-based path to building apps on the Salesforce Lightning Platform.
In the third episode of our five part series on Lightning Web Components, we cover design considerations and compositions of Lightning Web Components.
This document provides an overview of Lightning Web Components Episode 2 which focuses on working with Salesforce data. It discusses how the Lightning Data Service and UI API are used to retrieve and display Salesforce record data. It also demonstrates how to use wire services to connect Lightning Web Components to Apex methods to retrieve and manipulate data. The document concludes with instructions for configuring Lightning Web Components to be used in the Lightning App Builder.
Lightning Web Components are a JavaScript programming model for building web applications and interfaces that is built on the best of web standards.
Any front-end web developer can get started with LWC and leverage custom elements, and JavaScript APIs to create modern apps and experiences that are fully aware of Salesforce data and processes.
Migrate legacy Salesforce CPQ to Advanced Calculator with the help of JSQCP. With Advanced Calculator, you can boost the runtime of quote creation. Join this webinar to learn what is required for migration - we’ll also walk through JSQCP.
This document discusses techniques for addressing large data volumes (LDV) in Salesforce orgs, including big objects. Big objects are a special type of object designed to store and retrieve large data volumes using big data technology. The document also provides a use case where a company wants to archive closed cases to free up storage space while maintaining access. It recommends using a custom big object to address these needs. The webinar will demonstrate creating and deploying a custom big object and retrieving data using asynchronous SOQL.
Replicate Salesforce Data in Real Time with Change Data CaptureSalesforce Developers
Migrate your batch processing, scheduled ETL, and nightly workloads to event-driven, real-time integrations using Change Data Capture. CDC means data change events are published to an event stream, allowing businesses to have up-to-date information across systems and applications. Join us to learn how to configure Change Data Capture and subscribe to the stream of change events, streamlining your architectures and processes.
This document provides an overview of modern development with Salesforce DX. It discusses using source control and metadata with scratch orgs and the Salesforce CLI for source-driven development. Visual Studio Code is highlighted as an IDE for Salesforce development with features like the Salesforce extension pack. The document contrasts traditional org-based development with the new paradigm of package development where changes are tracked relative to package versions. It demonstrates these concepts with a live demo and encourages attendees to learn more on Trailhead.
Lightning Flow makes it easier for developers to build dynamic process-driven apps with Process Builder and the new Flow Builder. Join us and learn more about how you can get in the Flow!
Integrate CMS Content Into Lightning Communities with CMS ConnectSalesforce Developers
In this webinar we will show you how to display content from external Content Management Systems into Lightning Communities. This lets you take advantage of the Communities framework and help you centralize content in whatever CMS system you have chosen.
Building Production Ready Search Pipelines with Spark and MilvusZilliz
Spark is the widely used ETL tool for processing, indexing and ingesting data to serving stack for search. Milvus is the production-ready open-source vector database. In this talk we will show how to use Spark to process unstructured data to extract vector representations, and push the vectors to Milvus vector database for search serving.
Communications Mining Series - Zero to Hero - Session 1DianaGray10
This session provides introduction to UiPath Communication Mining, importance and platform overview. You will acquire a good understand of the phases in Communication Mining as we go over the platform with you. Topics covered:
• Communication Mining Overview
• Why is it important?
• How can it help today’s business and the benefits
• Phases in Communication Mining
• Demo on Platform overview
• Q/A
Observability Concepts EVERY Developer Should Know -- DeveloperWeek Europe.pdfPaige Cruz
Monitoring and observability aren’t traditionally found in software curriculums and many of us cobble this knowledge together from whatever vendor or ecosystem we were first introduced to and whatever is a part of your current company’s observability stack.
While the dev and ops silo continues to crumble….many organizations still relegate monitoring & observability as the purview of ops, infra and SRE teams. This is a mistake - achieving a highly observable system requires collaboration up and down the stack.
I, a former op, would like to extend an invitation to all application developers to join the observability party will share these foundational concepts to build on:
Dr. Sean Tan, Head of Data Science, Changi Airport Group
Discover how Changi Airport Group (CAG) leverages graph technologies and generative AI to revolutionize their search capabilities. This session delves into the unique search needs of CAG’s diverse passengers and customers, showcasing how graph data structures enhance the accuracy and relevance of AI-generated search results, mitigating the risk of “hallucinations” and improving the overall customer journey.
Maruthi Prithivirajan, Head of ASEAN & IN Solution Architecture, Neo4j
Get an inside look at the latest Neo4j innovations that enable relationship-driven intelligence at scale. Learn more about the newest cloud integrations and product enhancements that make Neo4j an essential choice for developers building apps with interconnected data and generative AI.
Unlock the Future of Search with MongoDB Atlas_ Vector Search Unleashed.pdfMalak Abu Hammad
Discover how MongoDB Atlas and vector search technology can revolutionize your application's search capabilities. This comprehensive presentation covers:
* What is Vector Search?
* Importance and benefits of vector search
* Practical use cases across various industries
* Step-by-step implementation guide
* Live demos with code snippets
* Enhancing LLM capabilities with vector search
* Best practices and optimization strategies
Perfect for developers, AI enthusiasts, and tech leaders. Learn how to leverage MongoDB Atlas to deliver highly relevant, context-aware search results, transforming your data retrieval process. Stay ahead in tech innovation and maximize the potential of your applications.
#MongoDB #VectorSearch #AI #SemanticSearch #TechInnovation #DataScience #LLM #MachineLearning #SearchTechnology
Removing Uninteresting Bytes in Software FuzzingAftab Hussain
Imagine a world where software fuzzing, the process of mutating bytes in test seeds to uncover hidden and erroneous program behaviors, becomes faster and more effective. A lot depends on the initial seeds, which can significantly dictate the trajectory of a fuzzing campaign, particularly in terms of how long it takes to uncover interesting behaviour in your code. We introduce DIAR, a technique designed to speedup fuzzing campaigns by pinpointing and eliminating those uninteresting bytes in the seeds. Picture this: instead of wasting valuable resources on meaningless mutations in large, bloated seeds, DIAR removes the unnecessary bytes, streamlining the entire process.
In this work, we equipped AFL, a popular fuzzer, with DIAR and examined two critical Linux libraries -- Libxml's xmllint, a tool for parsing xml documents, and Binutil's readelf, an essential debugging and security analysis command-line tool used to display detailed information about ELF (Executable and Linkable Format). Our preliminary results show that AFL+DIAR does not only discover new paths more quickly but also achieves higher coverage overall. This work thus showcases how starting with lean and optimized seeds can lead to faster, more comprehensive fuzzing campaigns -- and DIAR helps you find such seeds.
- These are slides of the talk given at IEEE International Conference on Software Testing Verification and Validation Workshop, ICSTW 2022.
“An Outlook of the Ongoing and Future Relationship between Blockchain Technologies and Process-aware Information Systems.” Invited talk at the joint workshop on Blockchain for Information Systems (BC4IS) and Blockchain for Trusted Data Sharing (B4TDS), co-located with with the 36th International Conference on Advanced Information Systems Engineering (CAiSE), 3 June 2024, Limassol, Cyprus.
For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2024/06/building-and-scaling-ai-applications-with-the-nx-ai-manager-a-presentation-from-network-optix/
Robin van Emden, Senior Director of Data Science at Network Optix, presents the “Building and Scaling AI Applications with the Nx AI Manager,” tutorial at the May 2024 Embedded Vision Summit.
In this presentation, van Emden covers the basics of scaling edge AI solutions using the Nx tool kit. He emphasizes the process of developing AI models and deploying them globally. He also showcases the conversion of AI models and the creation of effective edge AI pipelines, with a focus on pre-processing, model conversion, selecting the appropriate inference engine for the target hardware and post-processing.
van Emden shows how Nx can simplify the developer’s life and facilitate a rapid transition from concept to production-ready applications.He provides valuable insights into developing scalable and efficient edge AI solutions, with a strong focus on practical implementation.
Driving Business Innovation: Latest Generative AI Advancements & Success StorySafe Software
Are you ready to revolutionize how you handle data? Join us for a webinar where we’ll bring you up to speed with the latest advancements in Generative AI technology and discover how leveraging FME with tools from giants like Google Gemini, Amazon, and Microsoft OpenAI can supercharge your workflow efficiency.
During the hour, we’ll take you through:
Guest Speaker Segment with Hannah Barrington: Dive into the world of dynamic real estate marketing with Hannah, the Marketing Manager at Workspace Group. Hear firsthand how their team generates engaging descriptions for thousands of office units by integrating diverse data sources—from PDF floorplans to web pages—using FME transformers, like OpenAIVisionConnector and AnthropicVisionConnector. This use case will show you how GenAI can streamline content creation for marketing across the board.
Ollama Use Case: Learn how Scenario Specialist Dmitri Bagh has utilized Ollama within FME to input data, create custom models, and enhance security protocols. This segment will include demos to illustrate the full capabilities of FME in AI-driven processes.
Custom AI Models: Discover how to leverage FME to build personalized AI models using your data. Whether it’s populating a model with local data for added security or integrating public AI tools, find out how FME facilitates a versatile and secure approach to AI.
We’ll wrap up with a live Q&A session where you can engage with our experts on your specific use cases, and learn more about optimizing your data workflows with AI.
This webinar is ideal for professionals seeking to harness the power of AI within their data management systems while ensuring high levels of customization and security. Whether you're a novice or an expert, gain actionable insights and strategies to elevate your data processes. Join us to see how FME and AI can revolutionize how you work with data!
Pushing the limits of ePRTC: 100ns holdover for 100 daysAdtran
At WSTS 2024, Alon Stern explored the topic of parametric holdover and explained how recent research findings can be implemented in real-world PNT networks to achieve 100 nanoseconds of accuracy for up to 100 days.
GraphSummit Singapore | The Future of Agility: Supercharging Digital Transfor...Neo4j
Leonard Jayamohan, Partner & Generative AI Lead, Deloitte
This keynote will reveal how Deloitte leverages Neo4j’s graph power for groundbreaking digital twin solutions, achieving a staggering 100x performance boost. Discover the essential role knowledge graphs play in successful generative AI implementations. Plus, get an exclusive look at an innovative Neo4j + Generative AI solution Deloitte is developing in-house.
Climate Impact of Software Testing at Nordic Testing DaysKari Kakkonen
My slides at Nordic Testing Days 6.6.2024
Climate impact / sustainability of software testing discussed on the talk. ICT and testing must carry their part of global responsibility to help with the climat warming. We can minimize the carbon footprint but we can also have a carbon handprint, a positive impact on the climate. Quality characteristics can be added with sustainability, and then measured continuously. Test environments can be used less, and in smaller scale and on demand. Test techniques can be used in optimizing or minimizing number of tests. Test automation can be used to speed up testing.
How to Get CNIC Information System with Paksim Ga.pptxdanishmna97
Pakdata Cf is a groundbreaking system designed to streamline and facilitate access to CNIC information. This innovative platform leverages advanced technology to provide users with efficient and secure access to their CNIC details.
HCL Notes and Domino License Cost Reduction in the World of DLAUpanagenda
Webinar Recording: https://www.panagenda.com/webinars/hcl-notes-and-domino-license-cost-reduction-in-the-world-of-dlau/
The introduction of DLAU and the CCB & CCX licensing model caused quite a stir in the HCL community. As a Notes and Domino customer, you may have faced challenges with unexpected user counts and license costs. You probably have questions on how this new licensing approach works and how to benefit from it. Most importantly, you likely have budget constraints and want to save money where possible. Don’t worry, we can help with all of this!
We’ll show you how to fix common misconfigurations that cause higher-than-expected user counts, and how to identify accounts which you can deactivate to save money. There are also frequent patterns that can cause unnecessary cost, like using a person document instead of a mail-in for shared mailboxes. We’ll provide examples and solutions for those as well. And naturally we’ll explain the new licensing model.
Join HCL Ambassador Marc Thomas in this webinar with a special guest appearance from Franz Walder. It will give you the tools and know-how to stay on top of what is going on with Domino licensing. You will be able lower your cost through an optimized configuration and keep it low going forward.
These topics will be covered
- Reducing license cost by finding and fixing misconfigurations and superfluous accounts
- How do CCB and CCX licenses really work?
- Understanding the DLAU tool and how to best utilize it
- Tips for common problem areas, like team mailboxes, functional/test users, etc
- Practical examples and best practices to implement right away
AI 101: An Introduction to the Basics and Impact of Artificial IntelligenceIndexBug
Imagine a world where machines not only perform tasks but also learn, adapt, and make decisions. This is the promise of Artificial Intelligence (AI), a technology that's not just enhancing our lives but revolutionizing entire industries.
Sudheer Mechineni, Head of Application Frameworks, Standard Chartered Bank
Discover how Standard Chartered Bank harnessed the power of Neo4j to transform complex data access challenges into a dynamic, scalable graph database solution. This keynote will cover their journey from initial adoption to deploying a fully automated, enterprise-grade causal cluster, highlighting key strategies for modelling organisational changes and ensuring robust disaster recovery. Learn how these innovations have not only enhanced Standard Chartered Bank’s data infrastructure but also positioned them as pioneers in the banking sector’s adoption of graph technology.
UiPath Test Automation using UiPath Test Suite series, part 5DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 5. In this session, we will cover CI/CD with devops.
Topics covered:
CI/CD with in UiPath
End-to-end overview of CI/CD pipeline with Azure devops
Speaker:
Lyndsey Byblow, Test Suite Sales Engineer @ UiPath, Inc.
UiPath Test Automation using UiPath Test Suite series, part 5
See Androids Fighting: Connect Salesforce with Your Android Wear Watch
1. See Androids Fighting
Dr. Holger Kremmin
Program Architect
hkremmin@salesforce.com
@kremminh
Integrating your Android Wear Watch with Salesforce
2. Safe harbor statement under the Private Securities Litigation Reform Act of 1995:
This presentation may contain forward-looking statements that involve risks, uncertainties, and assumptions. If any such uncertainties
materialize or if any of the assumptions proves incorrect, the results of salesforce.com, inc. could differ materially from the results expressed
or implied by the forward-looking statements we make. All statements other than statements of historical fact could be deemed forward-
looking, including any projections of product or service availability, subscriber growth, earnings, revenues, or other financial items and any
statements regarding strategies or plans of management for future operations, statements of belief, any statements concerning new,
planned, or upgraded services or technology developments and customer contracts or use of our services.
The risks and uncertainties referred to above include – but are not limited to – risks associated with developing and delivering new
functionality for our service, new products and services, our new business model, our past operating losses, possible fluctuations in our
operating results and rate of growth, interruptions or delays in our Web hosting, breach of our security measures, the outcome of any
litigation, risks associated with completed and any possible mergers and acquisitions, the immature market in which we operate, our
relatively limited operating history, our ability to expand, retain, and motivate our employees and manage our growth, new releases of our
service and successful customer deployment, our limited history reselling non-salesforce.com products, and utilization and selling to larger
enterprise customers. Further information on potential factors that could affect the financial results of salesforce.com, inc. is included in our
annual report on Form 10-K for the most recent fiscal year and in our quarterly report on Form 10-Q for the most recent fiscal quarter.
These documents and others containing important disclosures are available on the SEC Filings section of the Investor Information section
of our Web site.
Any unreleased services or features referenced in this or other presentations, press releases or public statements are not currently available
and may not be delivered on time or at all. Customers who purchase our services should make the purchase decisions based upon features
that are currently available. Salesforce.com, inc. assumes no obligation and does not intend to update these forward-looking statements.
Safe Harbor
3. Objectives
In this session you will learn about:
§ Anatomy of an Android Wear Application
§ Integration Options
§ Leveraging Salesforce Mobile SDK for Android
§ How to setup your Android Studio Project
§ Leverage Example Code
After this session you should have a good understanding to
quickly create a stunning Salesforce Android Wear application
4. Not covered
In this session you will not learn :
§ Oauth
§ Android application architecture
§ The Salesforce Rest API
§ Devolping for an Apple Watch …
Change pic
7. Architectural Overview – Android Wear
Message API
Data API
Node API
Wearable App
Companion App
Awesome
Companion App
Play Services
Wearable App
intents
Awesome App
Android OS
Android W
OS
Wearable
App
8. UI Building Blocks - Android Wear is different!
Users are used to tapping icons to launch apps. A typical Wear app adds a card to the stream at a contextually
relevant moment. It might have a button that opens a full screen view, but it just as well might not.
Contextual card Full Screen UI Watch Face
§ Bridged Notifications (no
development on Wear
Device!)
§ Contextual Notifications
§ 2D Picker
§ Custom Layouts
§ Custom Watch Face
designs
9. Salesforce Mobile SDK
Push Notifications Container Wrappers Files MDM Policies
Enterprise Identity & Security
SmartStore Encrypted Database
SmartSync Data Management
OS UI Frameworks Any Web Framework
SalesforceSDKManager.initNative(getApplicationContext(), new KeyImpl(), DreamActivity.class);
SalesforceSDKManager.getInstance().setPushNotificationReceiver(new TravelPushNotification(this));
public class DreamActivity extends SalesforceActivity {
10. Architectural Overview – Salesforce Integration using GCM
Connected App Companion App
Notifications
Internet Internet
11. Architectural Overview – Direct Integration using REST-API
Internet
Message API
Data API
Node API
13. Setting Up Google Cloud Messaging (GCM)
Get a new configuration at developer.google.com (Developer account required)
123456789012
ABC123JKL4567fyzu89012hjr
What you get:
• Package Name
• Server API Key
• Sender ID
Com.dreamforce
14. Configure the Connected App in Salesforce
At least a Developer Org & Admin rights required
from Google
15. A lot of keys...What goes Where?
Key Source Destination
Server API Key Google Developer Salesforce Connected App
-> Mobile App Settings
-> Key for Server Applications
(API Key)
Sender ID Google Developer Resource File:
<string
name="androidPushNotificationClientId">
123456789012
</string>
Android Package Name Google Developer Resource File:
<string name="app_package">com.example.app
</string>
Consumer Key Salesforce Resource File:
<string name="remoteAccessConsumerKey">
3MVG9xOCXq...
</string>
16. Setting Up Android Studio
§ Usage of Android Studio is
highly recommended
§ Create a Library project for
the Mobile SDK so you can
reference it easily from your
projects
§ Good Practice: Shared
project for constants,
resources etc.
§ Gradle as Build System
§ Use real devices for
debugging instead of using
Emulators
19. Apex Code Snippet – Create & Send Notification/ Message
// send the notification
Messaging.PushNotification msg = new Messaging.PushNotification();
Map<String, Object> payload = new Map<String, Object>();
payload.put('ownerName', owner.Name);
payload.put('ownerFullPhotoUrl', owner.FullPhotoUrl);
...
msg.setPayload(payload);
// The approver's Id
String userId = result.actorIds[0];
Set<String> users = new Set<String>();
users.add(userId);
msg.send('Android_Wear', users);
Create Message Object
Create Payload
Add Payload to Message
Add target Users
Send Message to target
Users
20. Implement PushNotificationInterface
PushNotificationInterface is a Mobile SDK Android interface for
handling push notifications. PushNotificationInterface has a
single method, onPushMessageReceived(Bundle message).
public class TravelPushNotification implements PushNotificationInterface {
...
@Override
public void onPushMessageReceived(final Bundle bundle) {
... //create an async task if you perform network tasks etc!
Eg. Build your notification HERE
21. Create Notifications with the Notification Builder
The v4 support library allows you to create notifications using the latest
notification features such as action buttons and large icons.
To create a notification with the support library, you create an instance of
NotificationCompat.Builder and issue the notification by passing it to notify()
// Main notification
NotificationCompat.Builder mainNotification = new NotificationCompat.Builder(context)
.setSmallIcon(R.drawable.s1_icon)
.setContentTitle(travelMessage.ownerName)
.setContentText(“Travel approval required: " + travelMessage.travelName);
...
// Open Card
mainNotification.setContentIntent(openPendingIntent);
NotificationManagerCompat.from(context).notify(1, mainNotification.build());
22. Add Wearable Features For a Notification
If you ever need to add wearable-specific options to a notification, such
as specifying additional pages of content or letting users dictate a text
response with voice input, you can use the
NotificationCompat.WearableExtender class to specify the options.
WearableExtender wearableExtender = new WearableExtender()
.addAction(approveAction)
.addAction(rejectAction)
.addPage(detailNotification);
mainNotification.extend(wearableExtender);
26. The Wearable Data Layer API is part of Google Play services and provides a
communication channel for your companion and wearable apps. The API
supports the synchronization of data objects over the wire and eventing.
The Data API
A DataItem provides data storage with
automatic syncing between the
handheld and wearable.
Asset objects are for sending binary
blobs of data, such as images. You
attach assets to data items and the
system automatically takes care of the
transfer for you, conserving Bluetooth
bandwidth by caching large assets to
avoid re-transmission.
WearableListenerService lets you
listen for important data layer events in a
service. The system manages the lifecycle
of the WearableListenerService
DataListener lets you listen for
important data layer events when an
activity is in the foreground. Lets you listen
for changes only when the user is actively
using your app.
You can use the ChannelApi class to
transfer large data items, such as music
and movie files, from a handheld to a
wearable device.
The MessageApi class can send
messages and is good for remote
procedure calls (RPC), such as controlling
a handheld's media player from the
wearable or starting an intent on the
wearable from the handheld. Messages
are also great for one-way requests or for a
request/response communication model.
Data Events Channel / Message
27. For Demonstration of the Data Sync we create a full screen
UI wearable app
An Android wear application is nearly identical to a normal smartphone app. In our example we
will use the Data API to exchange Data between the Wear device and the companion app running
on the smart phone. For our example we could also use the Message API.
Extend the MainActivity if you want to listen to data events on the UI Thread.
// Main Activity
public class MainActivity extends Activity
implements ConnectionCallbacks, OnConnectionFailedListener,
DataApi.DataListener, MessageApi.MessageListener, NodeApi.NodeListener {
... Your App Code goes here
@Override
public void onDataChanged(DataEventBuffer dataEvents) {
....
If you want to listen to Data change Events
28. Speech Recognition
Voice actions (System- or App provided “OK Google, …) and the system's built-in Speech
Recognizer activity can be used to obtain speech input from users.
// Create an intent that can start the Speech Recognizer activity
private void displaySpeechRecognizer() {
Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,
RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
// Start the activity, the intent will be populated with the speech text
startActivityForResult(intent, SPEECH_REQUEST_CODE);
}
// invoked when the Speech Recognizer returns, extract the speech text from the intent.
@Override
protected void onActivityResult(int requestCode, int resultCode,Intent data) {
if (resultCode == RESULT_OK) {
List<String> results = data.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);
chatterText = results.get(0);
<create & send the data event>
}
29. Sending Data
A DataItem defines the data interface that the system uses to synchronize data between handhelds and
wearables. A DataItem generally consists of the following items:
§ Payload - A byte array, which you can set with whatever data you wish, allowing you to do your own object
serialization and deserialization. The size of the payload is limited to 100KB.
§ Path - A unique string that must start with a forward slash (for instance, "/salesforce/wearable/chatter")
// Create a data map and put data in it
private void createChatterData(String post) {
//Create the data request object
PutDataMapRequest putDataMapReq = PutDataMapRequest.create (“/chatter ");
putDataMapReq.getDataMap().putString(CHATTER_KEY, post);
PutDataRequest putDataReq = putDataMapReq.asPutDataRequest();
// Adds a DataItem to the Android Wear network. à synchronized across all devices
PendingResult<DataApi.DataItemResult> pendingResult =
Wearable.DataApi.putDataItem(mGoogleApiClient, putDataReq);
}
...
30. A DataLayerService will listen on all data events
The data layer synchronizes and sends data across the handheld and wearable, you normally want to listen
for important events, such as when data items are created, are received, etc. Options:
§ Create a service that extends WearableListenerService.
§ Create an activity that implements DataApi.DataListener.
public class DataLayerListenerService extends WearableListenerService {
/.../
@Override
public void onDataChanged(DataEventBuffer dataEvents) {
if (!mGoogleApiClient.isConnected()... //check for connectivity!!!
// Loop through the events for (DataEvent event : dataEvents) {
Uri uri = event.getDataItem().getUri();
String path = uri.getPath();
if (COUNT_PATH.equals(path)) {
// get the payload
byte[] payload = uri.toString().getBytes();
// *Chatter something J
postChatterMessage(payload);
...
Leveraging the
MobileSDK
(Authentication, Rest
Calls etc…)
* See https://github.com/forcedotcom/JavaChatterRESTApi by Jasper Roel
31. Speech Recognition is a great feature, but...
Hello Chatter
Dreamforce is
Awesome
Willkommen auf
der Dreamforce
Who needs the
Apple Watch?
Who will win
the Super
Bowl?
32. Key Takeaways
§ Keep your Wear UI as simple as possible!!!
§ Always test on real devices
§ The Salesforce Mobile SDK and Connected Apps handle most of the
connection complexity for your application
§ Wear Devices are mainly informative devices or to automatically
collect data
§ The Notification is a great and simple way to expand your existing
Android app to Wear Watches without the need to code a custom
Wear app
33. Share Your Feedback, and Win a GoPro!
3
Earn a GoPro prize entry for each completed
surveyTap the bell to take a survey2Enroll in a session1
36. UI Building Blocks - Android Wear is different!
Users are used to tapping icons to launch apps. A typical Wear app adds a card to the stream at a contextually
relevant moment. It might have a button that opens a full screen view, but it just as well might not.
Application Type Device
Devlopment
Contextual card in the
stream
Bridged notifications, such as new message notifications, are pushed to the
wearable from the connected handheld using standard Android notifications.
They require very little or no Wear-specific code.
✗
Contextual notifications, such as an exercise card that appears when you
begin running, are generated locally on the wearable and appear at
contextually relevant moments. You can do more with this kind of card than
with a notification bridged from the handheld.
✔
Full screen UI app: 2D Picker is a design pattern that allows the user to select from a set of items,
such as to select an artist then an album. We recommend using this pre-built
component from the SDK whenever relevant.
✔
Custom layouts are also possible where apps need to extend beyond the
basic card/stream metaphor, such as to present a graph or map. ✔
Keep your app always-on if you have information that refreshes or stays
relevant, without draining the battery. ✔
Watch Face Android Wear supports custom watch faces with designs that can show
contextually relevant information to users. ✔