1// Copyright 2014 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#ifndef MOJO_PUBLIC_APPLICATION_APPLICATION_IMPL_H_ 6#define MOJO_PUBLIC_APPLICATION_APPLICATION_IMPL_H_ 7#include <vector> 8 9#include "mojo/public/cpp/application/application_connection.h" 10#include "mojo/public/cpp/application/lib/service_connector.h" 11#include "mojo/public/cpp/application/lib/service_registry.h" 12#include "mojo/public/cpp/system/core.h" 13#include "mojo/public/interfaces/application/application.mojom.h" 14#include "mojo/public/interfaces/application/shell.mojom.h" 15 16namespace mojo { 17 18class ApplicationDelegate; 19 20// Utility class for communicating with the Shell, and providing Services 21// to clients. 22// 23// To use define a class that implements your specific server api, e.g. FooImpl 24// to implement a service named Foo. 25// That class must subclass an InterfaceImpl specialization. 26// 27// If there is context that is to be shared amongst all instances, define a 28// constructor with that class as its only argument, otherwise define an empty 29// constructor. 30// 31// class FooImpl : public InterfaceImpl<Foo> { 32// public: 33// FooImpl(ApplicationContext* app_context) {} 34// }; 35// 36// or 37// 38// class BarImpl : public InterfaceImpl<Bar> { 39// public: 40// // contexts will remain valid for the lifetime of BarImpl. 41// BarImpl(ApplicationContext* app_context, BarContext* service_context) 42// : app_context_(app_context), servicecontext_(context) {} 43// 44// Create an ApplicationImpl instance that collects any service implementations. 45// 46// ApplicationImpl app(service_provider_handle); 47// app.AddService<FooImpl>(); 48// 49// BarContext context; 50// app.AddService<BarImpl>(&context); 51// 52// 53class ApplicationImpl : public InterfaceImpl<Application> { 54 public: 55 ApplicationImpl(ApplicationDelegate* delegate, 56 ScopedMessagePipeHandle shell_handle); 57 ApplicationImpl(ApplicationDelegate* delegate, 58 MojoHandle shell_handle); 59 virtual ~ApplicationImpl(); 60 61 Shell* shell() const { return shell_.get(); } 62 63 // Returns any initial configuration arguments, passed by the Shell. 64 const Array<String>& args() { return args_; } 65 66 // Establishes a new connection to an application. Caller does not own. 67 ApplicationConnection* ConnectToApplication(const String& application_url); 68 69 // Connect to application identified by |application_url| and connect to the 70 // service implementation of the interface identified by |Interface|. 71 template <typename Interface> 72 void ConnectToService(const std::string& application_url, 73 InterfacePtr<Interface>* ptr) { 74 ConnectToApplication(application_url)->ConnectToService(ptr); 75 } 76 77 private: 78 class ShellPtrWatcher; 79 80 void BindShell(ScopedMessagePipeHandle shell_handle); 81 void ClearConnections(); 82 void OnShellError() { 83 ClearConnections(); 84 Terminate(); 85 }; 86 87 // Quits the main run loop for this application. 88 static void Terminate(); 89 90 // Application implementation. 91 virtual void Initialize(Array<String> args) MOJO_OVERRIDE; 92 virtual void AcceptConnection(const String& requestor_url, 93 ServiceProviderPtr provider) MOJO_OVERRIDE; 94 95 typedef std::vector<internal::ServiceRegistry*> ServiceRegistryList; 96 97 bool initialized_; 98 ServiceRegistryList incoming_service_registries_; 99 ServiceRegistryList outgoing_service_registries_; 100 ApplicationDelegate* delegate_; 101 ShellPtr shell_; 102 ShellPtrWatcher* shell_watch_; 103 Array<String> args_; 104 105 MOJO_DISALLOW_COPY_AND_ASSIGN(ApplicationImpl); 106}; 107 108} // namespace mojo 109 110#endif // MOJO_PUBLIC_APPLICATION_APPLICATION_IMPL_H_ 111