Added tests. Fixes #1364

example/generator/GeneratorProvider.js

@@ -41,6 +41,10 @@ define([
         return domainObject.type === 'generator';
     };
 
+    GeneratorProvider.prototype.supportsRequest =
+        GeneratorProvider.prototype.supportsSubscribe =
+            GeneratorProvider.prototype.canProvideTelemetry;
+
     GeneratorProvider.prototype.makeWorkerRequest = function (domainObject, request) {
         var props = [
             'amplitude',

example/generator/SinewaveConstants.js

@@ -19,7 +19,7 @@
  * this source code distribution or the Licensing information page available
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
-/*global define,Promise*/
+/*global define*/
 
 define({
     START_TIME: Date.now() - 24 * 60 * 60 * 1000 // Now minus a day.

example/generator/SinewaveDeltaFormat.js

@@ -19,12 +19,11 @@
  * this source code distribution or the Licensing information page available
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
-/*global define,Promise*/
+/*global define*/
 
 define(
     ['./SinewaveConstants', 'moment'],
     function (SinewaveConstants, moment) {
-        "use strict";
 
         var START_TIME = SinewaveConstants.START_TIME,
             FORMAT_REGEX = /^-?\d+:\d+:\d+$/,

example/generator/bundle.js

@@ -1,184 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-/*global define*/
-
-define([
-    "./src/SinewaveTelemetryProvider",
-    "./src/SinewaveLimitCapability",
-    "./src/SinewaveDeltaFormat",
-    'legacyRegistry'
-], function (
-    SinewaveTelemetryProvider,
-    SinewaveLimitCapability,
-    SinewaveDeltaFormat,
-    legacyRegistry
-) {
-    "use strict";
-
-    legacyRegistry.register("example/generator", {
-        "name": "Sine Wave Generator",
-        "description": "For development use. Generates example streaming telemetry data using a simple sine wave algorithm.",
-        "extensions": {
-            "components": [
-                {
-                    "implementation": SinewaveTelemetryProvider,
-                    "type": "provider",
-                    "provides": "telemetryService",
-                    "depends": [
-                        "$q",
-                        "$timeout"
-                    ]
-                }
-            ],
-            "capabilities": [
-                {
-                    "key": "limit",
-                    "implementation": SinewaveLimitCapability
-                }
-            ],
-            "formats": [
-                {
-                    "key": "example.delta",
-                    "implementation": SinewaveDeltaFormat
-                }
-            ],
-            "constants": [
-                {
-                    "key": "TIME_CONDUCTOR_DOMAINS",
-                    "value": [
-                        {
-                            "key": "time",
-                            "name": "Time"
-                        },
-                        {
-                            "key": "yesterday",
-                            "name": "Yesterday"
-                        },
-                        {
-                            "key": "delta",
-                            "name": "Delta"
-                        }
-                    ],
-                    "priority": -1
-                }
-            ],
-            "types": [
-                {
-                    "key": "generator",
-                    "name": "Sine Wave Generator",
-                    "cssClass": "icon-telemetry",
-                    "description": "For development use. Generates example streaming telemetry data using a simple sine wave algorithm.",
-                    "priority": 10,
-                    "features": "creation",
-                    "model": {
-                        "telemetry": {
-                            "period": 10,
-                            "amplitude": 1,
-                            "offset": 0,
-                            "dataRateInHz": 1
-                        }
-                    },
-                    "telemetry": {
-                        "source": "generator",
-                        "domains": [
-                            {
-                                "key": "utc",
-                                "name": "Time",
-                                "format": "utc"
-                            },
-                            {
-                                "key": "yesterday",
-                                "name": "Yesterday",
-                                "format": "utc"
-                            },
-                            {
-                                "key": "delta",
-                                "name": "Delta",
-                                "format": "example.delta"
-                            }
-                        ],
-                        "ranges": [
-                            {
-                                "key": "sin",
-                                "name": "Sine"
-                            },
-                            {
-                                "key": "cos",
-                                "name": "Cosine"
-                            }
-                        ]
-                    },
-                    "properties": [
-                        {
-                            "name": "Period",
-                            "control": "textfield",
-                            "cssClass": "l-input-sm l-numeric",
-                            "key": "period",
-                            "required": true,
-                            "property": [
-                                "telemetry",
-                                "period"
-                            ],
-                            "pattern": "^\\d*(\\.\\d*)?$"
-                        },
-                        {
-                            "name": "Amplitude",
-                            "control": "textfield",
-                            "cssClass": "l-input-sm l-numeric",
-                            "key": "amplitude",
-                            "required": true,
-                            "property": [
-                                "telemetry",
-                                "amplitude"
-                            ],
-                            "pattern": "^\\d*(\\.\\d*)?$"
-                        },
-                        {
-                            "name": "Offset",
-                            "control": "textfield",
-                            "cssClass": "l-input-sm l-numeric",
-                            "key": "offset",
-                            "required": true,
-                            "property": [
-                                "telemetry",
-                                "offset"
-                            ],
-                            "pattern": "^\\d*(\\.\\d*)?$"
-                        },
-                        {
-                            "name": "Data Rate (hz)",
-                            "control": "textfield",
-                            "cssClass": "l-input-sm l-numeric",
-                            "key": "dataRateInHz",
-                            "required": true,
-                            "property": [
-                                "telemetry",
-                                "dataRateInHz"
-                            ],
-                            "pattern": "^\\d*(\\.\\d*)?$"
-                        }
-                    ]
-                }
-            ]
-        }
-    });
-});

example/generator/plugin.js

@@ -0,0 +1,171 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2016, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+/*global define*/
+
+define([
+    "./GeneratorProvider",
+    "./SinewaveLimitCapability",
+    "./SinewaveDeltaFormat"
+], function (
+    GeneratorProvider,
+    SinewaveLimitCapability,
+    SinewaveDeltaFormat
+) {
+
+    var legacyExtensions = {
+        "capabilities": [
+            {
+                "key": "limit",
+                "implementation": SinewaveLimitCapability
+            }
+        ],
+        "formats": [
+            {
+                "key": "example.delta",
+                "implementation": SinewaveDeltaFormat
+            }
+        ],
+        "constants": [
+            {
+                "key": "TIME_CONDUCTOR_DOMAINS",
+                "value": [
+                    {
+                        "key": "time",
+                        "name": "Time"
+                    },
+                    {
+                        "key": "yesterday",
+                        "name": "Yesterday"
+                    },
+                    {
+                        "key": "delta",
+                        "name": "Delta"
+                    }
+                ],
+                "priority": -1
+            }
+        ]
+    }
+
+    return function(openmct){
+        //Register legacy extensions for things not yet supported by the new API
+        Object.keys(legacyExtensions).forEach(function (type){
+            var extensionsOfType = legacyExtensions[type];
+            extensionsOfType.forEach(function (extension) {
+                openmct.legacyExtension(type, extension)
+            })
+        });
+        openmct.types.register("generator", {
+            label: "Sine Wave Generator",
+            description: "For development use. Generates example streaming telemetry data using a simple sine wave algorithm.",
+            cssClass: "icon-telemetry",
+            creatable: true,
+            form: [
+                {
+                    name: "Period",
+                    control: "textfield",
+                    cssClass: "l-input-sm l-numeric",
+                    key: "period",
+                    required: true,
+                    property: [
+                        "telemetry",
+                        "period"
+                    ],
+                    pattern: "^\\d*(\\.\\d*)?$"
+                },
+                {
+                    name: "Amplitude",
+                    control: "textfield",
+                    cssClass: "l-input-sm l-numeric",
+                    key: "amplitude",
+                    required: true,
+                    property: [
+                        "telemetry",
+                        "amplitude"
+                    ],
+                    pattern: "^\\d*(\\.\\d*)?$"
+                },
+                {
+                    name: "Offset",
+                    control: "textfield",
+                    cssClass: "l-input-sm l-numeric",
+                    key: "offset",
+                    required: true,
+                    property: [
+                        "telemetry",
+                        "offset"
+                    ],
+                    pattern: "^\\d*(\\.\\d*)?$"
+                },
+                {
+                    name: "Data Rate (hz)",
+                    control: "textfield",
+                    cssClass: "l-input-sm l-numeric",
+                    key: "dataRateInHz",
+                    required: true,
+                    property: [
+                        "telemetry",
+                        "dataRateInHz"
+                    ],
+                    pattern: "^\\d*(\\.\\d*)?$"
+                }
+            ],
+            initialize: function (object) {
+                object.telemetry = {
+                    period: 10,
+                    amplitude: 1,
+                    offset: 0,
+                    dataRateInHz: 1,
+                    domains: [
+                        {
+                            key: "utc",
+                            name: "Time",
+                            format: "utc"
+                        },
+                        {
+                            key: "yesterday",
+                            name: "Yesterday",
+                            format: "utc"
+                        },
+                        {
+                            key: "delta",
+                            name: "Delta",
+                            format: "example.delta"
+                        }
+                    ],
+                    ranges: [
+                        {
+                            key: "sin",
+                            name: "Sine"
+                        },
+                        {
+                            key: "cos",
+                            name: "Cosine"
+                        }
+                    ]
+                };
+            }
+        });
+        openmct.telemetry.addProvider(new GeneratorProvider());
+    };
+
+});

index.html

@@ -28,17 +28,25 @@
     <script src="bower_components/requirejs/require.js">
     </script>
     <script>
-        require(['openmct'], function (openmct) {
+        require(['openmct'], function (openmct, generatorPlugin) {
             [
                 'example/imagery',
-                'example/eventGenerator',
+                'example/eventGenerator'
-                'example/generator'
             ].forEach(
                 openmct.legacyRegistry.enable.bind(openmct.legacyRegistry)
             );
             openmct.install(openmct.plugins.myItems);
             openmct.install(openmct.plugins.localStorage);
             openmct.install(openmct.plugins.espresso);
+
+            openmct.install(openmct.plugins.Generator());
+            openmct.install(openmct.plugins.UTCTimeSystem());
+            openmct.install(openmct.plugins.Conductor({
+                defaultTimeSystem: 'utc',
+                defaultTimespan: 30 * 60 * 1000,
+                showConductor: true
+            }));
+
             openmct.start();
         });
     </script>

platform/commonUI/edit/src/creation/CreateWizard.js

@@ -118,7 +118,7 @@ define(
                 formModel = this.createModel(formValue);
 
             formModel.location = parent.getId();
-            this.domainObject.useCapability("mutation", function () {
+            this.domainObject.useCapability("mutation", function (model) {
                 return formModel;
             });
             return this.domainObject;

platform/features/conductor/core/bundle.js

@@ -70,8 +70,9 @@ define([
                         "$location",
                         "openmct",
                         "timeConductorViewService",
-                        "timeSystems[]",
+                        "formatService",
-                        "formatService"
+                        "DEFAULT_TIMECONDUCTOR_MODE",
+                        "SHOW_TIMECONDUCTOR"
                     ]
                 },
                 {
@@ -150,6 +151,13 @@ define([
                     "link": "https://github.com/d3/d3/blob/master/LICENSE"
                 }
             ],
+            "constants": [
+                {
+                    "key": "DEFAULT_TIMECONDUCTOR_MODE",
+                    "value": "realtime",
+                    "priority": "fallback"
+                }
+            ],
             "formats": [
                 {
                     "key": "number",

platform/features/conductor/core/res/templates/time-conductor.html

@@ -1,8 +1,7 @@
 <!-- Parent holder for time conductor. follow-mode | fixed-mode -->
 <div ng-controller="TimeConductorController as tcController"
     class="holder grows flex-elem l-flex-row l-time-conductor {{modeModel.selectedKey}}-mode {{timeSystemModel.selected.metadata.key}}-time-system"
-        ng-class="{'status-panning': tcController.panning}">
+        ng-class="{'status-panning': tcController.panning}" ng-show="showTimeConductor">
-
     <div class="flex-elem holder time-conductor-icon">
         <div class="hand-little"></div>
         <div class="hand-big"></div>

platform/features/conductor/core/src/ui/TimeConductorController.js

@@ -40,7 +40,16 @@ define(
          * @memberof platform.features.conductor
          * @constructor
          */
-        function TimeConductorController($scope, $window, $location, openmct, conductorViewService, timeSystems, formatService) {
+        function TimeConductorController(
+            $scope,
+            $window,
+            $location,
+            openmct,
+            conductorViewService,
+            formatService,
+            DEFAULT_MODE,
+            SHOW_TIMECONDUCTOR
+        ) {
 
             var self = this;
 
@@ -59,11 +68,10 @@ define(
             this.modes = conductorViewService.availableModes();
             this.validation = new TimeConductorValidation(this.conductor);
             this.formatService = formatService;
+            this.DEFAULT_MODE = DEFAULT_MODE;
 
             // Construct the provided time system definitions
-            this.timeSystems = timeSystems.map(function (timeSystemConstructor) {
+            this.timeSystems = conductorViewService.systems;
-                return timeSystemConstructor();
-            });
 
             this.initializeScope();
             var searchParams = JSON.parse(JSON.stringify(this.$location.search()));
@@ -94,6 +102,8 @@ define(
             //Respond to any subsequent conductor changes
             this.conductor.on('bounds', this.changeBounds);
             this.conductor.on('timeSystem', this.changeTimeSystem);
+
+            this.$scope.showTimeConductor = SHOW_TIMECONDUCTOR;
         }
 
         /**
@@ -139,7 +149,7 @@ define(
             //Set mode from url if changed
             if (searchParams[SEARCH.MODE] === undefined ||
                 searchParams[SEARCH.MODE] !== this.$scope.modeModel.selectedKey) {
-                this.setMode(searchParams[SEARCH.MODE] || "fixed");
+                this.setMode(searchParams[SEARCH.MODE] || this.DEFAULT_MODE);
             }
 
             if (searchParams[SEARCH.TIME_SYSTEM] &&

platform/features/conductor/core/src/ui/TimeConductorControllerSpec.js

@@ -130,8 +130,9 @@ define(['./TimeConductorController'], function (TimeConductorController) {
                     mockLocation,
                     {conductor: mockTimeConductor},
                     mockConductorViewService,
-                    mockTimeSystems,
+                    mockFormatService,
-                    mockFormatService
+                    "fixed",
+                    true
                 );
 
                 tsListener = getListener(mockTimeConductor.on, "timeSystem");
@@ -244,7 +245,6 @@ define(['./TimeConductorController'], function (TimeConductorController) {
             var ts1Metadata;
             var ts2Metadata;
             var ts3Metadata;
-            var mockTimeSystemConstructors;
 
             beforeEach(function () {
                 mode = "realtime";
@@ -276,11 +276,7 @@ define(['./TimeConductorController'], function (TimeConductorController) {
                 ];
 
                 //Wrap in mock constructors
-                mockTimeSystemConstructors = mockTimeSystems.map(function (mockTimeSystem) {
+                mockConductorViewService.systems = mockTimeSystems;
-                    return function () {
-                        return mockTimeSystem;
-                    };
-                });
 
                 controller = new TimeConductorController(
                     mockScope,
@@ -288,8 +284,9 @@ define(['./TimeConductorController'], function (TimeConductorController) {
                     mockLocation,
                     {conductor: mockTimeConductor},
                     mockConductorViewService,
-                    mockTimeSystemConstructors,
+                    mockFormatService,
-                    mockFormatService
+                    "fixed",
+                    true
                 );
             });
 
@@ -434,12 +431,7 @@ define(['./TimeConductorController'], function (TimeConductorController) {
                     }
                 };
 
-                mockTimeSystems.push(function () {
+                mockConductorViewService.systems = [timeSystem, otherTimeSystem];
-                    return timeSystem;
-                });
-                mockTimeSystems.push(function () {
-                    return otherTimeSystem;
-                });
 
                 urlBounds = {
                     start: 100,
@@ -467,8 +459,9 @@ define(['./TimeConductorController'], function (TimeConductorController) {
                     mockLocation,
                     {conductor: mockTimeConductor},
                     mockConductorViewService,
-                    mockTimeSystems,
+                    mockFormatService,
-                    mockFormatService
+                    "fixed",
+                    true
                 );
 
                 spyOn(controller, "setMode");

platform/features/conductor/utcTimeSystem/bundle.js

@@ -34,23 +34,7 @@ define([
                     "implementation": UTCTimeSystem,
                     "depends": ["$timeout"]
                 }
-            ],
-            "runs": [
-                {
-                    "implementation": function (openmct, $timeout) {
-                        // Temporary shim to initialize the time conductor to
-                        // something
-                        if (!openmct.conductor.timeSystem()) {
-                            var utcTimeSystem = new UTCTimeSystem($timeout);
-
-                            openmct.conductor.timeSystem(utcTimeSystem, utcTimeSystem.defaults().bounds);
-                        }
-                    },
-                    "depends": ["openmct", "$timeout"],
-                    "priority": "fallback"
-                }
             ]
         }
     });
-
 });

platform/features/conductor/utcTimeSystem/src/UTCTimeSystem.js

@@ -48,6 +48,7 @@ define([
 
         this.fmts = ['utc'];
         this.sources = [new LocalClock($timeout, DEFAULT_PERIOD)];
+        this.defaultValues = undefined;
     }
 
     UTCTimeSystem.prototype = Object.create(TimeSystem.prototype);
@@ -64,18 +65,25 @@ define([
         return this.sources;
     };
 
-    UTCTimeSystem.prototype.defaults = function () {
+    UTCTimeSystem.prototype.defaults = function (defaults) {
+        if (arguments.length > 0) {
+            this.defaultValues = defaults;
+        }
+
+        if (this.defaultValues === undefined) {
             var now = Math.ceil(Date.now() / 1000) * 1000;
             var ONE_MINUTE = 60 * 1 * 1000;
             var FIFTY_YEARS = 50 * 365 * 24 * 60 * 60 * 1000;
 
-        return {
+            this.defaultValues = {
                 key: 'utc-default',
                 name: 'UTC time system defaults',
                 deltas: {start: FIFTEEN_MINUTES, end: 0},
                 bounds: {start: now - FIFTEEN_MINUTES, end: now},
                 zoom: {min: FIFTY_YEARS, max: ONE_MINUTE}
             };
+        }
+        return this.defaultValues;
     };
 
     return UTCTimeSystem;

platform/telemetry/bundle.js

@@ -79,6 +79,7 @@ define([
                     "key": "telemetry",
                     "implementation": TelemetryCapability,
                     "depends": [
+                        "openmct",
                         "$injector",
                         "$q",
                         "$log"

platform/telemetry/src/TelemetryCapability.js

@@ -24,8 +24,12 @@
  * Module defining TelemetryCapability. Created by vwoeltje on 11/12/14.
  */
 define(
-    [],
+    [
-    function () {
+        '../../../src/api/objects/object-utils'
+    ],
+    function (
+        objectUtils
+    ) {
 
         var ZERO = function () {
             return 0;
@@ -103,7 +107,7 @@ define(
          * @implements {Capability}
          * @constructor
          */
-        function TelemetryCapability($injector, $q, $log, domainObject) {
+        function TelemetryCapability(openmct, $injector, $q, $log, domainObject) {
             // We could depend on telemetryService directly, but
             // there isn't a platform implementation of this.
             this.initializeTelemetryService = function () {
@@ -118,7 +122,7 @@ define(
                 }
             };
 
-
+            this.openmct = openmct;
             this.$q = $q;
             this.$log = $log;
             this.domainObject = domainObject;
@@ -160,6 +164,20 @@ define(
         };
 
 
+        function asSeries(telemetry, defaultDomain, defaultRange) {
+            return {
+                getRangeValue: function (index, range) {
+                    return telemetry[index][range || defaultRange];
+                },
+                getDomainValue: function (index, domain) {
+                    return telemetry[index][domain || defaultDomain];
+                },
+                getPointCount: function () {
+                    return telemetry.length;
+                }
+            };
+        }
+
         /**
          * Request telemetry data for this specific domain object.
          * @param {TelemetryRequest} [request] parameters for this
@@ -169,12 +187,22 @@ define(
          */
         TelemetryCapability.prototype.requestData = function requestTelemetry(request) {
             // Bring in any defaults from the object model
-            var fullRequest = this.buildRequest(request || {}),
+            var fullRequest = this.buildRequest(request || {});
-                source = fullRequest.source,
+            var source = fullRequest.source;
-                key = fullRequest.key,
+            var key = fullRequest.key;
-                telemetryService = this.telemetryService ||
+            var telemetryService = this.telemetryService ||
                 this.initializeTelemetryService(); // Lazy initialization
 
+            var domainObject = objectUtils.toNewFormat(this.domainObject.getModel(), this.domainObject.getId());
+            var telemetryAPI = this.openmct.telemetry;
+
+            var metadata = telemetryAPI.getMetadata(domainObject);
+            var defaultDomain = (metadata.valuesForHints(['domain'])[0] || {}).key;
+            var defaultRange = (metadata.valuesForHints(['range'])[0] || {}).key;
+
+            var isLegacyProvider = telemetryAPI.findRequestProvider(domainObject) ===
+                telemetryAPI.legacyProvider;
+
             // Pull out the relevant field from the larger,
             // structured response.
             function getRelevantResponse(response) {
@@ -187,11 +215,18 @@ define(
                 return telemetryService.requestTelemetry([fullRequest]);
             }
 
+            // TODO: Adapt request / options?
+            if (isLegacyProvider) {
                 // If a telemetryService is not available,
                 // getTelemetryService() should reject, and this should
                 // bubble through subsequent then calls.
                 return telemetryService &&
                     requestTelemetryFromService().then(getRelevantResponse);
+            } else {
+                return telemetryAPI.request(domainObject, fullRequest).then(function (telemetry) {
+                    return asSeries(telemetry, defaultDomain, defaultRange);
+                });
+            }
         };
 
         /**
@@ -217,12 +252,26 @@ define(
          *        subscription request
          */
         TelemetryCapability.prototype.subscribe = function subscribe(callback, request) {
-            var fullRequest = this.buildRequest(request || {}),
+            var fullRequest = this.buildRequest(request || {});
-                telemetryService = this.telemetryService ||
+            var telemetryService = this.telemetryService ||
                 this.initializeTelemetryService(); // Lazy initialization
 
+            var domainObject = objectUtils.toNewFormat(this.domainObject.getModel(), this.domainObject.getId());
+            var telemetryAPI = this.openmct.telemetry;
+
+            var metadata = telemetryAPI.getMetadata(domainObject);
+            var defaultDomain = (metadata.valuesForHints(['domain'])[0] || {}).key;
+            var defaultRange = (metadata.valuesForHints(['range'])[0] || {}).key;
+
+            var isLegacyProvider = telemetryAPI.findSubscriptionProvider(domainObject) ===
+                telemetryAPI.legacyProvider;
+
+            function update(telemetry) {
+                callback(asSeries([telemetry], defaultDomain, defaultRange));
+            }
+
             // Unpack the relevant telemetry series
-            function update(telemetries) {
+            function updateLegacy(telemetries) {
                 var source = fullRequest.source,
                     key = fullRequest.key,
                     result = ((telemetries || {})[source] || {})[key];
@@ -231,8 +280,13 @@ define(
                 }
             }
 
+            // Avoid a loop here...
+            if (isLegacyProvider) {
                 return telemetryService &&
-                telemetryService.subscribe(update, [fullRequest]);
+                    telemetryService.subscribe(updateLegacy, [fullRequest]);
+            } else {
+                return telemetryAPI.subscribe(domainObject, update, fullRequest);
+            }
         };
 
         /**

platform/telemetry/test/TelemetryCapabilitySpec.js

@@ -32,8 +32,9 @@ define(
                 mockTelemetryService,
                 mockReject,
                 mockUnsubscribe,
-                telemetry;
+                telemetry,
-
+                mockTelemetryAPI,
+                mockAPI;
 
             function mockPromise(value) {
                 return {
@@ -43,6 +44,9 @@ define(
                 };
             }
 
+            function noop() {
+            }
+
             beforeEach(function () {
                 mockInjector = jasmine.createSpyObj("$injector", ["get"]);
                 mockQ = jasmine.createSpyObj("$q", ["when", "reject"]);
@@ -79,7 +83,25 @@ define(
                 // Bubble up...
                 mockReject.then.andReturn(mockReject);
 
+                mockTelemetryAPI = jasmine.createSpyObj("telemetryAPI", [
+                    "getMetadata",
+                    "subscribe",
+                    "request",
+                    "findRequestProvider",
+                    "findSubscriptionProvider"
+                ]);
+                mockTelemetryAPI.getMetadata.andReturn({
+                    valuesForHints: function () {
+                        return [];
+                    }
+                });
+
+                mockAPI = {
+                    telemetry: mockTelemetryAPI
+                };
+
                 telemetry = new TelemetryCapability(
+                    mockAPI,
                     mockInjector,
                     mockQ,
                     mockLog,
@@ -113,7 +135,6 @@ define(
                         key: "testKey", // from model
                         start: 42 // from argument
                     }]);
-
             });
 
             it("provides an empty series when telemetry is missing", function () {
@@ -161,6 +182,57 @@ define(
                 expect(mockLog.warn).toHaveBeenCalled();
             });
 
+            it("if a new style telemetry source is available, use it", function () {
+                var mockProvider = {};
+                mockTelemetryAPI.findSubscriptionProvider.andReturn(mockProvider);
+                telemetry.subscribe(noop, {});
+                expect(mockTelemetryService.subscribe).not.toHaveBeenCalled();
+                expect(mockTelemetryAPI.subscribe).toHaveBeenCalled();
+            });
+
+            it("if a new style telemetry source is not available, revert to old API", function () {
+                mockTelemetryAPI.findSubscriptionProvider.andReturn(undefined);
+                telemetry.subscribe(noop, {});
+                expect(mockTelemetryAPI.subscribe).not.toHaveBeenCalled();
+                expect(mockTelemetryService.subscribe).toHaveBeenCalled();
+            });
+
+            it("Wraps telemetry returned from the new API as a telemetry series", function () {
+                var returnedTelemetry;
+                var mockTelemetry = [{
+                    prop1: "val1",
+                    prop2: "val2",
+                    prop3: "val3"
+                },
+                {
+                    prop1: "val4",
+                    prop2: "val5",
+                    prop3: "val6"
+                }];
+                var mockProvider = {};
+                var dunzo = false;
+
+                mockTelemetryAPI.findRequestProvider.andReturn(mockProvider);
+                mockTelemetryAPI.request.andReturn(Promise.resolve(mockTelemetry));
+
+                telemetry.requestData({}).then(function (data) {
+                    returnedTelemetry = data;
+                    dunzo = true;
+                });
+
+                waitsFor(function () {
+                    return dunzo;
+                });
+
+                runs(function () {
+                    expect(returnedTelemetry.getPointCount).toBeDefined();
+                    expect(returnedTelemetry.getDomainValue).toBeDefined();
+                    expect(returnedTelemetry.getRangeValue).toBeDefined();
+                    expect(returnedTelemetry.getPointCount()).toBe(2);
+                });
+
+            });
+
             it("allows subscriptions to updates", function () {
                 var mockCallback = jasmine.createSpy("callback"),
                     subscription = telemetry.subscribe(mockCallback);

src/api/telemetry/TelemetryMetadataManager.js

@@ -105,7 +105,6 @@ define([
         this.valueMetadatas = this.valueMetadatas.map(applyReasonableDefaults);
     }
 
-
     /**
      * Get value metadata for a single key.
      */

src/api/types/TypeRegistry.js

@@ -51,7 +51,7 @@ define(['./Type'], function (Type) {
      * @method addType
      * @memberof module:openmct.TypeRegistry#
      */
-    TypeRegistry.prototype.addType = function (typeKey, typeDef) {
+    TypeRegistry.prototype.register = function (typeKey, typeDef) {
         this.types[typeKey] = new Type(typeDef);
     };
 

src/defaultRegistry.js

@@ -33,7 +33,6 @@ define([
     '../example/export/bundle',
     '../example/extensions/bundle',
     '../example/forms/bundle',
-    '../example/generator/bundle',
     '../example/identity/bundle',
     '../example/imagery/bundle',
     '../example/mobile/bundle',

src/plugins/plugins.js

@@ -21,16 +21,21 @@
  *****************************************************************************/
 
 define([
-    'lodash'
+    'lodash',
-], function (_) {
+    '../../platform/features/conductor/utcTimeSystem/src/UTCTimeSystem',
+    '../../example/generator/plugin'
+], function (
+    _,
+    UTCTimeSystem,
+    GeneratorPlugin
+) {
     var bundleMap = {
         couchDB: 'platform/persistence/couch',
         elasticsearch: 'platform/persistence/elastic',
         espresso: 'platform/commonUI/themes/espresso',
         localStorage: 'platform/persistence/local',
         myItems: 'platform/features/my-items',
-        snow: 'platform/commonUI/themes/snow',
+        snow: 'platform/commonUI/themes/snow'
-        utcTimeSystem: 'platform/features/conductor/utcTimeSystem'
     };
 
     var plugins = _.mapValues(bundleMap, function (bundleName, pluginName) {
@@ -39,6 +44,61 @@ define([
         };
     });
 
+    plugins.UTCTimeSystem = function () {
+        return function (openmct) {
+            openmct.legacyExtension("timeSystems", {
+                "implementation": UTCTimeSystem,
+                "depends": ["$timeout"]
+            });
+        };
+    };
+
+    plugins.Conductor = function (options) {
+        if (!options) {
+            options = {};
+        }
+
+        function applyDefaults(openmct, timeConductorViewService) {
+            var defaults = {};
+            var timeSystem = timeConductorViewService.systems.find(function (ts) {
+                return ts.metadata.key === options.defaultTimeSystem;
+            });
+            if (timeSystem !== undefined) {
+                defaults = timeSystem.defaults();
+
+                if (options.defaultTimespan !== undefined) {
+                    defaults.deltas.start = options.defaultTimespan;
+                    defaults.bounds.start = defaults.bounds.end - options.defaultTimespan;
+                    timeSystem.defaults(defaults);
+                }
+
+                openmct.conductor.timeSystem(timeSystem, defaults.bounds);
+            }
+        }
+
+        return function (openmct) {
+            openmct.legacyExtension('constants', {
+                key: 'DEFAULT_TIMECONDUCTOR_MODE',
+                value: options.showConductor ? 'fixed' : 'realtime',
+                priority: 'mandatory'
+            });
+            openmct.legacyExtension('constants', {
+                key: 'SHOW_TIMECONDUCTOR',
+                value: options.showConductor,
+                priority: 'mandatory'
+            });
+            if (options.defaultTimeSystem !== undefined || options.defaultTimespan !== undefined) {
+                openmct.legacyExtension('runs', {
+                    implementation: applyDefaults,
+                    depends: ["openmct", "timeConductorViewService"]
+                });
+            }
+
+            openmct.legacyRegistry.enable('platform/features/conductor/core');
+            openmct.legacyRegistry.enable('platform/features/conductor/compatibility');
+        };
+    };
+
     plugins.CouchDB = function (url) {
         return function (openmct) {
             if (url) {
@@ -83,5 +143,9 @@ define([
         };
     };
 
+    plugins.Generator = function () {
+        return GeneratorPlugin;
+    };
+
     return plugins;
 });