Table of Contents

• Title and Copyright Information
• Preface
  • Audience
  • Documentation Accessibility
  • Related Resources
  • Conventions
• Part I The Basics
  • 1 Get to Know Oracle Mobile Cloud Service
    • Jump in with Mobile Backends
    • Design Custom APIs
    • Implement APIs
    • Get the Data
    • Use Platform APIs
    • Call APIs from Your App Code
      • Call Platform APIs with Mobile SDKs
    • Set Up and Manage Your Mobile App Users
    • Deploy Code between MCS Environments
    • Monitor and Administer the Mobile Infrastructure
    • Analyze Your Mobile Projects
    • What About Security?
      • Video: Security Overview
    • Job Descriptions and Learning Paths
      • Mobile App Developer
      • Service Developer
      • Enterprise Architect
      • Mobile Cloud Administrator
      • Mobile Program Manager
  • 2 Set Up the Service
    • Where Do I Sign Up?
    • What Do I Need To Do?
    • Activate the Service
    • Create Mobile Environment Service Instances
      • Setting Up MCS Environments
      • Setting Up MAX Environments
    • Assign MCS Team Member Roles
      • MCS Team Member Roles
      • Distinguishing Between MAX Team Member Roles for Business Users and for Mobile App Developers
      • Example Team Member Role Assignments
    • Set Up Mobile Users, Realms and Roles
      • Creating Realms
      • Setting the Default Realm for an Environment
      • Creating and Managing Mobile User Roles
      • Creating Mobile Users and Assigning Roles
        • Creating Individual Mobile Users for Testing
        • Importing Groups of Mobile Users Into MCS Using Oracle Cloud
        • Mobile Users for MAX
        • Changing a Mobile User Password
      • Configuring Identity Management (SSO and OAuth)
        • Configuring Oracle Cloud Applications as the Identity Provider
    • Get on Board
• Part II Setting up Mobile Apps
  • 3 Mobile Backends
    • What Is a Mobile Backend and How Can I Use It?
    • What's the Mobile Backend Development Process?
    • Creating and Populating Mobile Backends
      • Creating a Mobile Backend
        • Mobile Backends for MAX Apps
      • Mobile Backend Authentication and Connection Info
      • Environments and Mobile Backends
      • Realms and Mobile Backends
        • Changing a Mobile Backend's Realm
      • Getting Test Users for a Mobile Backend
      • Associating APIs with a Mobile Backend
      • Associating Storage Collections with a Mobile Backend
      • Clients and Mobile Backends
      • What Can I Change in a Mobile Backend?
    • Video: Mobile Backend Design Considerations
    • The SDKs
    • Connecting Your App to a Mobile Backend
  • 4 Client Management
    • How Clients Work in MCS
    • Profiles
    • Creating a Profile
    • Registering an App as a Client in MCS
    • Legacy Client Behavior
  • 5 Authentication in MCS
    • OAuth Consumer Authentication in MCS
    • HTTP Basic Authentication in MCS
    • Enterprise Single Sign-On in MCS
      • Third-Party SAML and JWT Tokens
        • SAML Tokens and Virtual Users
          • Configuring SAML Tokens for Virtual Users
          • Registering the Token Issuer in MCS
          • Associating Roles with a SAML Token
          • Extracting the SAML Assertion
          • Using a SAML Token to Authenticate with MCS
          • Coding the SAML Token Exchange Manually
        • JWT Tokens and Virtual Users
          • Registering a JWT Token Issuer in MCS
          • Minimal IdP Configuration
          • IdP Configuration with Audience
          • IdP Configuration with Audience and Username Attribute
          • Associating Roles with a JWT Token
          • Converting a JSON Object to One Line
          • JWT Configuration Reference
          • Obtaining a JWT Token Using an Embedded Browser
          • Obtaining a JWT Token Using a System Browser
            • Coding Your Android App to Obtain a JWT Token
            • Coding Your iOS App to Obtain a JWT Token
          • Using a JWT Token to Authenticate with MCS
          • Coding the JWT Token Exchange Manually
        • Mapping Users from a Third-Party IdP to Oracle Cloud Users
        • Getting a Single Sign-On OAuth Token through a Browser
      • Enabling Browser-Based SSO through MCS
        • Enabling Single Sign-On for a Mobile Backend
        • Getting an SSO Token Using Form Post Response Mode
      • Testing APIs in a Mobile Backend with SSO Login
      • Token Expiration for SSO Login
    • Facebook Login in MCS
      • Registering an App for Login Through Facebook
      • Enabling Facebook Login in a Mobile Backend
      • Configuring an App to Use Facebook Login
      • Adding APIs to a Mobile Backend with Facebook Login
      • Getting a Facebook User Access Token Manually
      • Headers Needed for API Calls with Facebook Authentication
    • Authenticating in Direct REST Calls
      • Authenticating with OAuth in Direct REST Calls
      • Authenticating with HTTP Basic in Direct REST Calls
    • How OAuth Works in MCS
      • Resource Owner Password Credentials Grant - Authenticated Access
      • Client Credentials Grant - Unauthenticated Access
    • Securing Cross-Site Requests to MCS APIs
  • 6 Android Applications
    • Getting the SDK for Android
    • Contents of the Android SDK
      • Android SDK Dependencies
    • Adding the SDK to an Android App
    • Upgrading an Android App from SDK 17.x and Before
    • Configuring SDK Properties for Android
    • Configuring Your Android Manifest File
    • Loading a Mobile Backend's Configuration into an Android App
    • Authenticating and Logging In Using the SDK for Android
    • Calling Platform APIs Using the SDK for Android
    • Calling Custom APIs Using the SDK for Android
    • Video: Configuring an Existing Android App to Work with Mobile Cloud
  • 7 iOS Applications
    • Getting the SDK for iOS
    • Contents of the iOS SDK
    • Prerequisites for Developing iOS Apps
    • Adding the SDK to an iOS App
      • iOS SDK Interdependencies
    • Configuring SDK Properties for iOS
    • Loading a Mobile Backend's Configuration into an iOS App
    • Authenticating and Logging In Using the SDK for iOS
    • Calling Platform APIs Using the SDK for iOS
    • Calling Custom APIs Using the SDK for iOS
    • Video: Configuring an Existing iOS App to Work with Mobile Cloud
  • 8 Cordova Applications
    • Getting the SDK for Cordova
    • Contents of the Cordova SDK Bundle
    • Adding the SDK to a Cordova App
    • Configuring SDK Properties for Cordova
    • Loading a Mobile Backend's Configuration in a Cordova App
    • Authenticating and Logging In Using the SDK for Cordova
    • Setting Up a Cordova App for FCM or GCM Notifications
    • Securing Browser-Based Apps Against Cross-Site Request Forgery Attacks
    • Calling Platform APIs Using the SDK for Cordova
    • Calling Custom APIs Using the SDK for Cordova
  • 9 JavaScript Applications
    • Getting the SDK for JavaScript
    • Contents of the JavaScript SDK Bundle
    • Adding the SDK to a JavaScript App
    • Configuring SDK Properties for JavaScript
    • Loading a Mobile Backend's Configuration into a JavaScript App
    • Authenticating and Logging In Using the SDK for JavaScript
    • Securing Browser-Based Apps Against Cross-Site Request Forgery Attacks
    • Calling Platform APIs Using the SDK for JavaScript
      • Avoiding Unsafe Header Errors
    • Calling Custom APIs Using the SDK for JavaScript
  • 10 Xamarin Android Applications
    • Getting the SDK for Xamarin Android
    • Adding the SDK to a Xamarin Android Project
    • Configuring SDK Properties for Xamarin Android
    • Configuring Your AndroidManifest.xml File
    • Loading a Mobile Backend's Configuration into a Xamarin Android App
    • Authenticating and Logging In Using the SDK for Xamarin Android
    • Calling Platform APIs Using the SDK for Xamarin Android
      • User Management
      • Location
      • Storage
      • Notifications
      • Analytics
      • App Policies
    • Calling Custom APIs Using the SDK for Xamarin Android
  • 11 Xamarin iOS Applications
    • Getting the SDK for Xamarin iOS
    • Adding the SDK to a Xamarin iOS Project
    • Configuring SDK Properties for Xamarin iOS
    • Loading a Mobile Backend's Configuration into a Xamarin iOS App
    • Authenticating and Logging In Using the SDK for Xamarin iOS
    • Calling Platform APIs Using the SDK for Xamarin iOS
      • User Management
      • Location
      • Storage
      • Notifications
      • Analytics
      • App Policies
    • Calling Custom APIs Using the SDK for Xamarin iOS
• Part III Platform APIs
  • 12 Mobile User Management
    • User Types
    • Getting User Information
    • Getting User Roles
    • Updating Mobile User Custom Properties
  • 13 Location
    • What Can I Do With Location?
    • Setting Up Location Devices, Places and Assets
      • Defining Places
        • Uploading Places Using a CSV File
      • Defining Location Assets
        • Uploading Assets Using a CSV File
      • Registering Location Devices
        • Uploading Location Devices Using a CSV File
    • Calling the Location API from Your App
      • Querying for Location Devices, Places and Assets
        • Querying for Location Devices
        • Querying for Places
        • Querying for Assets
        • Using the SDK to Query for Location Objects: iOS
        • Using the SDK to Query for Location Objects: Android
      • Retrieving Location Objects and Properties
        • Using the SDK to Retrieve a Location Object: iOS
          • Using the SDK to Retrieve iBeacon Identifiers: iOS
          • Using the SDK to Define a Geofence: iOS
          • Using the SDK to Retrieve Custom Attributes: iOS
        • Using the SDK to Retrieve a Location Object: Android
  • 14 Storage
    • What is the Storage API?
      • How Mobile Applications Access Collections
      • Shared and User Isolated Collections
    • Working with Collections
      • Using the Storage Configuration Pages
      • Creating Collections
        • Defining a Collection
          • Collection Metadata
        • Adding Access Permissions to a Collection
        • Updating the Collection
        • Offline Data Storage
        • Adding Objects to a Collection
          • Object Metadata
      • Managing Collections
        • Associating a Collection with a Backend
        • Removing a Collection from a Backend
    • Calling the Storage API from Your App
    • Testing Runtime Operations Using the Endpoints Page
      • Storage API Endpoints
      • Getting a Single Collection
      • Getting All Collections Associated with a Mobile Backend
      • Storing an Object
        • Specifying the Object Identifier
        • Creating an Object (If One Doesn't Already Exist)
        • Generating an Object Identifier
        • What Happens When an Object is Created?
      • Updating an Object
        • What Happens When an Object Is Updated?
        • Optimistic Locking
      • Retrieving Objects
        • Retrieving a List of Objects
          • Paging Through a List of Objects
          • Ordering
          • Querying
        • Retrieving an Object
      • Deleting an Object
      • Optimizing Performance
        • Check If Exists
          • Put If Absent
        • Get If Newer
        • Reading Part of an Object (Chunking Data)
  • 15 Data Offline and Sync
    • Building Apps that Work Offline Using Sync Express
    • Building Apps that Work Offline Using the Synchronization Library
      • What Can I Do with the Synchronization Library?
      • Synchronization Library Process Flow
      • Video: Overview of the Data Offline & Synchronization API
      • Android Synchronization Library
        • Setting Up Your Mobile App for the Android Synchronization Library
        • Fetching Resources
        • Fetching Filtered Resources
        • Specifying Which Resources to Synchronize First
        • Setting a Resource’s Synchronization Policies Programmatically
        • Detecting and Handling Conflicts
        • Reviewing and Discarding Offline Edits
      • iOS Synchronization Library
        • Setting Up Your Mobile App for the iOS Synchronization Library
        • Fetching Resources
        • Fetching Filtered Resources
        • Specifying Which Resources To Synchronize First
        • Setting a Resource’s Synchronization Policies Programmatically
        • Detecting and Handling Conflicts
        • Reviewing and Discarding Offline Edits
      • Making Custom APIs Synchronizable
      • Synchronization Policies
        • Video: Introduction to the Data Offline & Sync Policies
        • Synchronization Policy Options
          • Conflict Resolution Policies
          • Eviction Policies
          • Expiration Policies
          • Fetch Policies
          • Update Policies
        • Video: Deep-Dive into the Data Offline & Sync Policies
        • Synchronization Policy Levels and Precedence
        • Defining Synchronization Policies Using a Configuration File
          • Synchronization Configuration File Structure
        • Defining Synchronization Policies and Cache Settings in a Response Header
      • Tracking Cache Hits with the Synchronization Library
    • How Synchronization Works with the Storage APIs
  • 16 Notifications
    • What Can I Do with Notifications?
    • How Are Notifications Sent and Received?
      • What is the Device ID or Notification Token?
    • Setting Up a Mobile App for Notifications
      • Setting Up Android Notifications
        • Android: Google API Key
        • Setting Up a Device Handshake for Android (FCM)
        • Setting Up a Device Handshake for Android (GCM)
      • Setting Up iOS Notifications
        • iOS: Apple Secure Certificates
        • Setting Up a Device Handshake for iOS
      • Setting Up Windows Notifications
        • Windows: WNS Credentials
        • Syniverse: SMS Credentials
        • Setting Up a Device Handshake for Windows
    • Sending Notifications to and from Your App
      • Testing Notifications from the MCS UI
        • Cancelling a Scheduled Notification from the UI
      • Sending Notifications Using the Notifications API
        • Registering a Device ID
        • Sending a Text Message Notification
        • Sending a Notification Using a Unified Payload
        • Sending a Notification Using a Payload Template
        • Cancelling Scheduled Notifications
    • Troubleshooting Notifications
      • Checking Notification Status in the UI
      • Checking Notification Status with the Notifications REST API
  • 17 Analytics
    • What Can I Do With Analytics?
    • How Does MCS Create Analytics Reports?
    • Enabling Your Mobile Apps to Report Event Data
      • Adding Location Properties to the context Event
    • Integrating Analytics into a Mobile App Using the Mobile Client SDK
    • Understanding Different Types of Analytics Reports
    • Accessing the Analytics Reports
    • API Calls Reports
      • API Calls Count
      • API Calls Response Time
    • Events Report
      • Events
    • User and Session Reports
      • User Reports
        • Why User Counts Can Vary
      • User Session Reports
      • New Users
      • Active Users
      • Session Count
      • Session Duration
    • Improving User Retention with Funnel Analysis
      • Creating a Funnel
      • Analyzing Funnels
    • Creating Custom Analytics Reports
      • How Do I Create a Custom Analytics Report?
      • My Reports
        • How Do I Run a Custom Report?
        • How Do I Edit a Custom Report?
    • Tracking Sessions and Logging Events for Mobile Apps
      • Creating Events and Sessions Using the iOS Library
        • Calling the Analytics Service
        • Designating Sessions
        • Associating a Session With Your Mobile App Being in the Foreground
        • Adding Custom Properties to Events
        • Receiving the Status of Event Posts
      • Creating Events and Sessions Using the Android Library
        • Taking a Look at Events and Sessions in Android Apps
      • Defining Sessions
    • Exporting Event Data
    • Purging Analytics Data
    • Troubleshooting Analytics Reports
  • 18 Database
    • What Can I Do with Database APIs?
    • Database Access API
      • Calling the Database Access API from Custom Code
      • Creating and Restructuring Database Tables
        • Preventing Passing SQL Using Implicit Table Creation
        • Adding and Updating Table Rows
        • Retrieving Table Rows
        • Deleting Table Rows
    • Database Management API
      • Creating a Table Explicitly
      • Copying Table Structures to Another Environment
      • Creating or Deleting an Index on a Table
  • 19 App Policies
    • What Are App Policies and What Can I Do With Them?
    • Setting an App Policy
    • Retrieving App Policies in App Code
    • Updating an App Policy Value in a Published Mobile Backend
• Part IV Custom APIs
  • 20 Creating APIs Fast with the Express API Designer
    • What are Resources?
    • How Do I Get Started with Resources?
      • Creating An API
      • Completing Your Resources
        • Adding Additional Fields
        • Shaping the Payload for Your Resource
        • Adding More Sample Data
      • Referenced Resources
        • Referencing Resources
      • Fields
      • Methods
        • Shaping Payloads
        • Read-Only Fields
      • Sample Data
    • Using the Express API Designer with MAX
      • Who Uses MAX?
      • Enabling Uploadable Images
      • Tips for User-Friendly Business Objects in MAX
      • Video: An Introduction to Mobile Application Accelerator (MAX)
    • Creating Resources with JSON Schemas
      • Defining Fields in a Schema
        • Defining Field Types, Formats, and Enums
      • Defining Child Objects
      • Defining Fields for List, Details, Create, and Update Screens
        • Collection Actions
        • Create Actions
        • Update Actions
          • Using the PUT Method for Update Actions
        • Delete Actions
        • Custom Actions
      • Creating Mock Data
    • Which API Designer Should I Use?
  • 21 Custom API Design
    • API Design Process
    • The API Designer
    • Generating Custom APIs for Connectors
      • How Do I Generate a Custom API from a Connector
      • Completing the Custom API
      • Working with the Implementation
    • Spec Out a Custom API
    • Creating a Complete Custom API
      • Setting Up Your API
      • Defining Endpoints
      • Adding Methods to Your Resources
      • Defining a Request for the Method
      • Defining a Response for the Method
      • Testing API Endpoints Using Mock Data
      • Providing a Schema
      • Security in Custom APIs
        • Setting Access to the API
      • Testing Your Custom API
      • Creating Resource Types
      • Creating Resource Traits
      • Providing API Documentation
        • How Do I Write in Markdown?
      • Getting Diagnostic Information
    • API Design Considerations
      • Valid URLs
      • API Timeouts
      • API Resources
        • URI Parameters
      • Endpoint Requirements for Sync Compatibility
      • Schemas
      • RAML
    • Editing a Custom API
    • Video: End-to-End Custom API Demo
    • Troubleshooting Custom APIs
  • 22 Implementing Custom APIs
    • What Can I Do with Custom Code?
    • How Does Custom Code Work?
      • What's the Foundation for the Custom Code Service?
      • Video: Node.js Technology Primer
    • Setting Up Tooling for Custom Code
    • Steps to Implement a Custom API
    • Downloading a JavaScript Scaffold for a Custom API
    • Writing Custom Code
      • Key JavaScript Constructs in Custom Code
      • Accessing the Body of the Request
      • Inserting Logging Into Custom Code
      • Storing Data Locally
      • Video: Working with Node - Common Code
    • Implementing Synchronization-Compatible APIs
      • Video: Working with Custom APIs via Data Offline & Sync
      • Requirements for a Synchronization-Compatible Custom API
      • Returning Cacheable Data
      • Specifying Synchronization and Cache Policies
    • Calling Web Services and APIs from Custom Code
    • Packaging Custom Code into a Module
      • Required Artifacts for an API Implementation
        • package.json Contents
      • Declaring the API Implementation Version
      • Declaring the Node Version
      • Packaging Additional Libraries with Your Implementation
    • Uploading the Custom Code Module
    • Managing Custom Code in Git
      • Setting Up a Git Repository for Custom Code
        • Designating a Git Repository for Custom Code
        • Setting Up a Git Repository in Oracle Developer Cloud Service
      • Generating a Scaffold in a Git Repository
    • Testing and Debugging Custom Code
      • Testing with Mock Data
      • Testing Custom Code from the UI
      • Offline Debugging with the MCS Custom Code Test Tools
      • Other Tools for Testing Custom Code Outside of the UI
      • Accessing Logging Messages for Custom Code
    • Troubleshooting Custom API Implementations
      • Diagnosing Syntax Errors
      • Common Custom Code Errors
    • What Happens When a Custom API Is Called?
  • 23 Calling APIs from Custom Code
    • How to Send Requests to MCS APIs
      • API Request Pattern
      • Common options Argument Properties
      • API Response Patterns
        • Handling a Stream
        • Handling a Promise
          • Chaining Calls
          • Joining Calls
          • Waiting for a Dynamic Set of Calls to Complete
          • Creating a Function that Returns a Promise
    • Accessing Mobile Backend Information from Custom Code
      • mbe.getMBE()
    • Calling Platform APIs from Custom Code
      • Accessing the Analytics API from Custom Code
        • analytics.postEvent(events, options, httpOptions)
      • Accessing the App Policies API from Custom Code
        • appConfig.getProperties(httpOptions)
      • Accessing the Database Access API from Custom Code
        • database.delete(table, keys, options, httpOptions)
        • database.get(table, keys, options, httpOptions)
        • database.getAll(table, options, httpOptions)
        • database.insert(table, object, options, httpOptions)
        • database.merge(table, object, options, httpOptions)
      • Accessing the Devices API from Custom Code
        • devices.deregister(device, httpOptions)
        • devices.register(device, httpOptions)
      • Accessing the Location API from Custom Code
        • location.assets.getAsset(id, httpOptions)
        • location.assets.query(queryObject, httpOptions)
        • location.devices.getDevice(id, httpOptions)
        • location.devices.query(queryObject, httpOptions)
        • location.places.getPlace(id, httpOptions)
        • location.places.query(queryObject, httpOptions)
      • Accessing the Location Management API from Custom Code
        • Location Management Context Argument
        • location.assets.register(assets, context, httpOptions)
        • location.assets.remove(id, context, httpOptions)
        • location.assets.update(id, asset, context, httpOptions)
        • location.devices.register(devices, context, httpOptions)
        • location.devices.remove(id, context, httpOptions)
        • location.devices.update(id, device, context, httpOptions)
        • location.places.register(places, context, httpOptions)
        • location.places.remove(id, context, httpOptions)
        • location.places.removeCascade(id, context, httpOptions)
        • location.places.update(id, place, context, httpOptions)
      • Accessing the Notifications API from Custom Code
        • Notifications Context Argument
        • notification.getAll(context, options, httpOptions)
        • notification.getById(id, context, options, httpOptions)
        • notification.post(notification, context, options, httpOptions)
        • notification.remove(id, context, options, httpOptions)
      • Accessing the Storage API from Custom Code
        • storage.doesCollectionExist(collectionId, options, httpOptions)
        • storage.doesExist(collectionId, objectId, options, httpOptions)
        • storage.getAll(collectionId, options, httpOptions)
        • storage.getById(collectionId, objectId, options, httpOptions)
        • storage.getCollection(collectionId, options, httpOptions)
        • storage.getCollections(options, httpOptions)
        • storage.remove(collectionId, objectId, options, httpOptions)
        • storage.store(collectionId, object, options, httpOptions)
        • storage.storeById(collectionId, objectId, object, options, httpOptions)
      • Accessing the Mobile Users API from Custom Code
        • ums.getUser(options, httpOptions)
        • ums.getUserExtended(options, httpOptions)
        • ums.updateUser(fields, options, httpOptions)
    • Calling Custom APIs from Custom Code
    • Calling Connector APIs from Custom Code
      • Calling a Connector to a REST Web Service
      • Calling a Connector to a SOAP Service
      • Calling Connectors that Require Form Data
      • Passing Headers to the Target Service
      • Overriding SSL Settings for Connectors
    • Specifying the API Version in Calls to Custom and Connector APIs
    • Using Generic REST Methods to Access APIs
      • optionsList Argument
    • Learning About Platform, Custom, and Connector APIs
• Part V Connector APIs
  • 24 REST Connector APIs
    • How REST Connector APIs Work
      • REST Connector API Design Process
    • Why Use Connectors Instead of Direct Calls to External Resources?
    • Creating a REST Connector API
      • Basic Connector Setup
      • Providing the Descriptor
      • Rules
      • Selecting Endpoints
      • Security Policies and Overriding Properties
        • Setting a CSF Key
      • Testing the REST Connector API
        • Testing in Standard Mode
        • Testing in Advanced Mode
      • Getting the Test Results
      • Getting Diagnostic Information
    • Security and REST Connector APIs
    • Security Policy Types for REST Connector APIs
    • CSF Keys and Web Service Certificates
    • Query and Header Parameters
      • Setting Query Parameters in Remote URLs
    • Editing a REST Connector API
    • Using Your Connector API in an App
    • Troubleshooting REST Connector APIs
  • 25 SOAP Connector APIs
    • How SOAP Connector APIs Work
      • SOAP Connector API Design Process
    • Why Use SOAP Connectors Instead of Direct Calls to External Resources?
    • Creating a SOAP Connector API
      • Setting the Basic Information for Your SOAP Connector API
      • Selecting a Port
      • Setting Security Policies and Overriding Properties for SOAP Connector APIs
        • Setting a CSF Key
        • Setting a Web Service Certificate
      • Testing a SOAP Connector API
        • Testing Your Connector
        • Getting the Test Results
        • Getting Diagnostic Information
    • SOAP Connector API Design Tips
    • How Does XML Get Translated into JSON?
    • XML - JSON Mapping Conventions
    • Using XML Instead of JSON
    • Security Policy Types for SOAP Connector APIs
    • CSF Keys and Web Service Certificates
    • Editing a SOAP Connector API
    • Using Your Connector API in an App
    • Troubleshooting SOAP Connector APIs
  • 26 ICS Connector APIs
    • How ICS Connector APIs Work
    • ICS Connector API Flow
    • How Do I Create an ICS Connector API?
      • Setting the Basic Information for Your ICS Connector API
      • Connecting to an Integration Cloud Service Instance
      • Selecting or Creating an ICS Instance Connection
      • Selecting an Active Integration
      • Editing the ICS Connector API
      • Setting Runtime Security for the ICS Connector API
      • Creating a New CSF Key
      • Testing the ICS Connector API
        • Getting the Test Results
        • Getting Diagnostic Information
    • Security and ICS Connector APIs
    • CSF Keys
    • Using Your Connector API in an App
    • Troubleshooting ICS Connector APIs
  • 27 Fusion Applications Connector APIs
    • How Fusion Applications Connector APIs Work
    • Fusion Applications Connector API Flow
    • How Do I Create a Fusion Applications Connector API?
      • Setting the Basic Information for Your Fusion Applications Connector API
      • Connecting to a Fusion Applications Instance
      • Creating a Fusion Applications Instance Connection
      • Selecting Fusion Applications Resources
      • Setting Resource Attributes
      • Editing the Fusion Applications Connector API
      • Setting Runtime Security for the Fusion Applications Connector API
        • Providing a CSF Key
        • Creating a New CSF Key
        • Setting a Web Service Certificate
      • Testing the Fusion Applications Connector API
        • Getting the Test Results
    • Security Policy Types for Fusion Applications Connector APIs
    • CSF Keys and Web Service Certificates
    • Using Your Fusion Application Connector API in an App
    • Troubleshooting Fusion Applications Connector APIs
• Part VI Deployment and Lifecycle
  • 28 MCS Environments
    • Team Members
    • What is My Environment?
      • Your Work Environment
        • Changing Environments
          • What Happens When You Change Environments?
    • Administration View
      • Changing Environment Views for the Administrator
    • Setting the Default Environment
    • Environment Policies
      • Environment Policy Names
      • Environment Policy Scopes
      • Modifying an Environment Policy
      • Removing Environment Policies
    • CSF Keys and Certificates
      • Viewing Available CSF Keys, Certificates, and Token Issuers
      • Configuring a CSF Key
      • Configuring a Web Service or Token Certificate
      • Configuring an SSL Certificate
      • Disabling SSL Hostname Verification
      • Adding a Token Issuer
      • Rules for Certificate Subject Names
      • Configuring Rules
      • Rule Types
      • Rule Examples
    • Native Builds
  • 29 Diagnostics
    • What Can I Do with Diagnostics?
      • Viewing Environment Health
        • Viewing Server Load
        • Viewing Errors
      • Viewing Underperforming Requests
      • Viewing Log Messages Related to a Request
      • Viewing Storage Usage
    • Monitoring a Selected Backend
    • Viewing API Performance
    • What Do the Health Indicator Thresholds Mean?
      • Adjusting the Performance Threshold Configurations
    • Viewing Status Codes for API Calls and Outbound Connector Calls
      • Relating Log Messages
        • How Client SDK Headers Enable Device and Session Diagnostics
    • Viewing Log Messages
      • Viewing Message Details
        • Taking a Look at Exported Messages
          • API Request Messages
          • Connector Message Details
      • Configuring the Logging Level for Custom Code
    • Diagnosing Custom Code
      • Use Case: Using Correlation to Diagnose Custom Code
      • Use Case: Using Correlation to Diagnose Connector Issues
    • Video: Logging and Diagnostic Examples
  • 30 Lifecycle
    • Draft State
    • Published State
      • Making Changes After a Backend is Published (Rerouting)
    • Deployment
    • Artifact Deletion
      • Dependencies That Affect a Move to the Trash
    • Restoring an Artifact
      • Restoring an Artifact from Administration
    • Purging an Artifact
      • Purging Artifacts from Administration
  • 31 Lifecycle Scenarios
    • Initial Deployment of a Mobile Backend
    • Bug Fix
    • Rerouting a Mobile Backend
    • New Features
  • 32 Managing an Artifact’s Lifecycle
    • Realm Lifecycle
      • Publishing a Realm
      • Creating a New Version of a Realm
      • Deploying a Realm
      • Moving a Realm to the Trash
      • Restoring a Realm
      • Managing a Realm
    • Client Lifecycle
      • Publishing a Client
      • Updating the Version Number of a Client
      • Creating a New Version of a Client
      • Deploying Clients
        • Specifying a Target Environment for the Client
        • Identifying Dependencies and Deployment Impact
        • Setting Environment Policies for Clients
        • Deploying the Client
      • Moving a Client to the Trash
      • Restoring a Client
      • Managing a Client
    • Mobile Backend Lifecycle
      • Backend Lifecycle States
      • Publishing a Mobile Backend
      • Updating the Version Number of a Backend
      • Creating a New Version of a Backend
      • Deploying Mobile Backends
        • Specifying a Target Environment for the Mobile Backend
        • Identifying Dependencies and Deployment Effects
        • Setting Environment Policies for Mobile Backends
        • Deploying the Mobile Backend
      • Moving a Backend to the Trash
      • Restoring a Backend
      • Deactivating a Backend
      • Managing a Mobile Backend
      • Mobile Client SDK Demo Applications
    • API Lifecycle
      • Publishing a Custom API
      • Custom APIs and API Implementations
      • Updating the Version Number of an API
      • Creating a New Version of an API
      • Deploying APIs
        • Specifying a Target Environment
        • Identifying Dependencies and Deployment Effects
        • Setting Environment Policies for APIs
        • Deploying the API
      • Moving a Custom API to the Trash
      • Restoring a Custom API
      • Managing an API
    • API Implementation Lifecycle
      • Publishing an API Implementation
      • Creating a New Version or Updating the Version of an API Implementation
      • Deploying an API Implementation
        • Specifying a Target Environment for the Implementation
        • Identifying Dependencies and Deployment Effects
        • Setting Environment Policies for an API Implementation
        • Deploying the Implementation
      • Moving an API Implementation to the Trash
      • Restoring an API Implementation
    • Connector Lifecycle
      • Publishing a Connector
      • Updating the Version Number of a Connector
      • Creating a New Version of a Connector
      • Deploying Connectors
        • Specifying a Target Environment
        • Identifying Dependencies and Deployment Effects
        • Setting Environment Policies for Connectors
        • Deploying the Connector
      • Moving a Connector to the Trash
      • Restoring a Connector
      • Managing a Connector
    • Collection Lifecycle
      • Publishing a Collection
      • Updating the Version Number of a Collection
      • Creating a New Version of a Collection
      • Deploying a Collection
      • Moving a Collection to the Trash
      • Restoring a Collection
      • Managing a Collection
  • 33 Testing APIs and Mobile Backends
    • Use Case: End-to-End Testing
    • How Can I Test an API?
      • Testing a Platform or Custom API from the UI
      • Testing a Connector API from the UI
      • Testing Platform and Custom APIs Remotely
    • Troubleshooting Unexpected Test Results
    • Monitoring Runtime Issues and System Health
  • 34 Packages
    • What’s a Package?
    • Why Do I Want a Package?
    • Exporting a Package
      • Adding Artifacts to the Package
      • Reviewing Dependencies During Export
      • Setting Environment Policies During Export
      • Completing the Export
    • Re-exporting a Package
    • Importing a Package
      • Uploading the Package
      • Examining the Contents of the Import Package
      • Setting Environment Policies During Import
    • What Happens When You Import a Package?
    • Import Results
    • Exporting Updated Artifacts
    • Examining a Package
    • Moving a Package to the Trash
    • Environment Policy Settings for Packaged Artifacts
• Reference
  • A HTTP Headers
    • API Headers
    • SDK Headers
  • B Oracle Mobile Cloud Service Environment Policies
    • Environment Policies and Their Values
  • C Security Policies for Connector APIs
    • Security Policies for REST Connector APIs
    • Security Policies for SOAP Connector APIs
    • Security Policies for ICS Connector APIs
    • Security Policies for Fusion Applications Connector APIs
    • Security Policy Properties
  • D Identity Domain Relocation
  • E Writing Swift Applications Using the iOS Client SDK
    • Adding the Bridging Header File
    • Adding the SDK Headers and Libraries to a Swift App
    • Using SDK Objects in Swift Apps
  • F Supported Browsers and Languages
    • Supported Browsers
    • Supported Languages
  • G Identity Provider Integration
    • Use Case: Configuring OKTA to Obtain a SAML Token
    • Use Case: Configuring AD FS to Obtain a SAML Token
    • Integrating Microsoft Azure Active Directory with Oracle Cloud
  • H Migrate to Oracle Mobile Hub
• Glossary