dom/bluetooth2/BluetoothService.h

   1 /* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
   2 /* vim: set ts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_dom_bluetooth_bluetootheventservice_h__
   8 #define mozilla_dom_bluetooth_bluetootheventservice_h__
   9
  10 #include "BluetoothCommon.h"
  11 #include "BluetoothProfileManagerBase.h"
  12 #include "mozilla/dom/ipc/Blob.h"
  13 #include "nsAutoPtr.h"
  14 #include "nsClassHashtable.h"
  15 #include "nsIDOMFile.h"
  16 #include "nsIObserver.h"
  17 #include "nsTObserverArray.h"
  18 #include "nsThreadUtils.h"
  19
  20 namespace mozilla {
  21 namespace ipc {
  22 class UnixSocketConsumer;
  23 }
  24 }
  25
  26 BEGIN_BLUETOOTH_NAMESPACE
  27
  28 class BluetoothManager;
  29 class BluetoothNamedValue;
  30 class BluetoothReplyRunnable;
  31 class BluetoothSignal;
  32
  33 typedef mozilla::ObserverList<BluetoothSignal> BluetoothSignalObserverList;
  34
  35 class BluetoothService : public nsIObserver
  36 {
  37   class ToggleBtTask;
  38   friend class ToggleBtTask;
  39
  40   class StartupTask;
  41   friend class StartupTask;
  42
  43 public:
  44   class ToggleBtAck : public nsRunnable
  45   {
  46   public:
  47     ToggleBtAck(bool aEnabled);
  48     NS_IMETHOD Run();
  49
  50   private:
  51     bool mEnabled;
  52   };
  53   friend class ToggleBtAck;
  54
  55   NS_DECL_ISUPPORTS
  56   NS_DECL_NSIOBSERVER
  57
  58   /**
  59    * Add a message handler object from message distribution observer.
  60    * Must be called from the main thread.
  61    *
  62    * @param aNodeName Node name of the object
  63    * @param aMsgHandler Weak pointer to the object
  64    */
  65   virtual void
  66   RegisterBluetoothSignalHandler(const nsAString& aNodeName,
  67                                  BluetoothSignalObserver* aMsgHandler);
  68
  69   /**
  70    * Remove a message handler object from message distribution observer.
  71    * Must be called from the main thread.
  72    *
  73    * @param aNodeName Node name of the object
  74    * @param aMsgHandler Weak pointer to the object
  75    */
  76   virtual void
  77   UnregisterBluetoothSignalHandler(const nsAString& aNodeName,
  78                                    BluetoothSignalObserver* aMsgHandler);
  79
  80   /**
  81    * Remove a message handlers for the given observer.
  82    * Must be called from the main thread.
  83    *
  84    * @param aMsgHandler Weak pointer to the object
  85    */
  86   void
  87   UnregisterAllSignalHandlers(BluetoothSignalObserver* aMsgHandler);
  88
  89   /**
  90    * Distribute a signal to the observer list
  91    *
  92    * @param aSignal Signal object to distribute
  93    *
  94    * @return NS_OK if signal distributed, NS_ERROR_FAILURE on error
  95    */
  96   void
  97   DistributeSignal(const BluetoothSignal& aEvent);
  98
  99   /**
 100    * Returns the BluetoothService singleton. Only to be called from main thread.
 101    *
 102    * @param aService Pointer to return singleton into.
 103    *
 104    * @return NS_OK on proper assignment, NS_ERROR_FAILURE otherwise (if service
 105    * has not yet been started, for instance)
 106    */
 107   static BluetoothService*
 108   Get();
 109
 110   static already_AddRefed<BluetoothService>
 111   FactoryCreate()
 112   {
 113     nsRefPtr<BluetoothService> service = Get();
 114     return service.forget();
 115   }
 116
 117   /**
 118    * Returns an array of each adapter's properties, implemented via a platform
 119    * specific method.
 120    *
 121    * @return NS_OK on success, NS_ERROR_FAILURE otherwise
 122    */
 123   virtual nsresult
 124   GetAdaptersInternal(BluetoothReplyRunnable* aRunnable) = 0;
 125
 126   /**
 127    * Returns the properties of paired devices, implemented via a platform
 128    * specific method.
 129    *
 130    * @return NS_OK on success, NS_ERROR_FAILURE otherwise
 131    */
 132   virtual nsresult
 133   GetPairedDevicePropertiesInternal(const nsTArray<nsString>& aDeviceAddresses,
 134                                     BluetoothReplyRunnable* aRunnable) = 0;
 135
 136   /**
 137    * Returns the properties of connected devices regarding to specific profile,
 138    * implemented via a platform specific methood.
 139    *
 140    * @return NS_OK on success, NS_ERROR_FAILURE otherwise
 141    */
 142   virtual nsresult
 143   GetConnectedDevicePropertiesInternal(uint16_t aServiceUuid,
 144                                        BluetoothReplyRunnable* aRunnable) = 0;
 145
 146   /**
 147    * Returns up-to-date uuids of given device address,
 148    * implemented via a platform specific methood.
 149    *
 150    * @return NS_OK on success, NS_ERROR_FAILURE otherwise
 151    */
 152   virtual nsresult
 153   FetchUuidsInternal(const nsAString& aDeviceAddress,
 154                      BluetoothReplyRunnable* aRunnable) = 0;
 155
 156   /**
 157    * Stop device discovery (platform specific implementation)
 158    *
 159    * @return NS_OK if discovery stopped correctly, false otherwise
 160    */
 161   virtual nsresult
 162   StopDiscoveryInternal(BluetoothReplyRunnable* aRunnable) = 0;
 163
 164   /**
 165    * Start device discovery (platform specific implementation)
 166    *
 167    * @return NS_OK if discovery stopped correctly, false otherwise
 168    */
 169   virtual nsresult
 170   StartDiscoveryInternal(BluetoothReplyRunnable* aRunnable) = 0;
 171
 172   /**
 173    * Set a property for the specified object
 174    *
 175    * @param aPropName Name of the property
 176    * @param aValue Boolean value
 177    * @param aRunnable Runnable to run on async reply
 178    *
 179    * @return NS_OK if property is set correctly, NS_ERROR_FAILURE otherwise
 180    */
 181   virtual nsresult
 182   SetProperty(BluetoothObjectType aType,
 183               const BluetoothNamedValue& aValue,
 184               BluetoothReplyRunnable* aRunnable) = 0;
 185
 186   virtual nsresult
 187   CreatePairedDeviceInternal(const nsAString& aAddress,
 188                              int aTimeout,
 189                              BluetoothReplyRunnable* aRunnable) = 0;
 190
 191   virtual nsresult
 192   RemoveDeviceInternal(const nsAString& aObjectPath,
 193                        BluetoothReplyRunnable* aRunnable) = 0;
 194
 195   /**
 196    * Get corresponding service channel of specific service on remote device.
 197    * It's usually the very first step of establishing an outbound connection.
 198    *
 199    * @param aObjectPath Object path of remote device
 200    * @param aServiceUuid UUID of the target service
 201    * @param aManager Instance which has callback function OnGetServiceChannel()
 202    *
 203    * @return NS_OK if the task begins, NS_ERROR_FAILURE otherwise
 204    */
 205   virtual nsresult
 206   GetServiceChannel(const nsAString& aDeviceAddress,
 207                     const nsAString& aServiceUuid,
 208                     BluetoothProfileManagerBase* aManager) = 0;
 209
 210   virtual bool
 211   UpdateSdpRecords(const nsAString& aDeviceAddress,
 212                    BluetoothProfileManagerBase* aManager) = 0;
 213
 214   virtual void
 215   SetPinCodeInternal(const nsAString& aDeviceAddress, const nsAString& aPinCode,
 216                      BluetoothReplyRunnable* aRunnable) = 0;
 217
 218   virtual void
 219   SetPasskeyInternal(const nsAString& aDeviceAddress, uint32_t aPasskey,
 220                      BluetoothReplyRunnable* aRunnable) = 0;
 221
 222   virtual void
 223   SetPairingConfirmationInternal(const nsAString& aDeviceAddress, bool aConfirm,
 224                                  BluetoothReplyRunnable* aRunnable) = 0;
 225
 226   virtual void
 227   Connect(const nsAString& aDeviceAddress, uint32_t aCod, uint16_t aServiceUuid,
 228           BluetoothReplyRunnable* aRunnable) = 0;
 229
 230   virtual void
 231   Disconnect(const nsAString& aDeviceAddress, uint16_t aServiceUuid,
 232              BluetoothReplyRunnable* aRunnable) = 0;
 233
 234   virtual bool
 235   IsConnected(uint16_t aServiceUuid) = 0;
 236
 237   virtual void
 238   SendFile(const nsAString& aDeviceAddress,
 239            BlobParent* aBlobParent,
 240            BlobChild* aBlobChild,
 241            BluetoothReplyRunnable* aRunnable) = 0;
 242
 243   virtual void
 244   SendFile(const nsAString& aDeviceAddress,
 245            nsIDOMBlob* aBlob,
 246            BluetoothReplyRunnable* aRunnable) = 0;
 247
 248   virtual void
 249   StopSendingFile(const nsAString& aDeviceAddress,
 250                   BluetoothReplyRunnable* aRunnable) = 0;
 251
 252   virtual void
 253   ConfirmReceivingFile(const nsAString& aDeviceAddress, bool aConfirm,
 254                        BluetoothReplyRunnable* aRunnable) = 0;
 255
 256   virtual void
 257   ConnectSco(BluetoothReplyRunnable* aRunnable) = 0;
 258
 259   virtual void
 260   DisconnectSco(BluetoothReplyRunnable* aRunnable) = 0;
 261
 262   virtual void
 263   IsScoConnected(BluetoothReplyRunnable* aRunnable) = 0;
 264
 265 #ifdef MOZ_B2G_RIL
 266   virtual void
 267   AnswerWaitingCall(BluetoothReplyRunnable* aRunnable) = 0;
 268
 269   virtual void
 270   IgnoreWaitingCall(BluetoothReplyRunnable* aRunnable) = 0;
 271
 272   virtual void
 273   ToggleCalls(BluetoothReplyRunnable* aRunnable) = 0;
 274 #endif
 275
 276   virtual void
 277   SendMetaData(const nsAString& aTitle,
 278                const nsAString& aArtist,
 279                const nsAString& aAlbum,
 280                int64_t aMediaNumber,
 281                int64_t aTotalMediaCount,
 282                int64_t aDuration,
 283                BluetoothReplyRunnable* aRunnable) = 0;
 284
 285   virtual void
 286   SendPlayStatus(int64_t aDuration,
 287                  int64_t aPosition,
 288                  const nsAString& aPlayStatus,
 289                  BluetoothReplyRunnable* aRunnable) = 0;
 290
 291   virtual void
 292   UpdatePlayStatus(uint32_t aDuration,
 293                    uint32_t aPosition,
 294                    ControlPlayStatus aPlayStatus) = 0;
 295
 296   virtual nsresult
 297   SendSinkMessage(const nsAString& aDeviceAddresses,
 298                   const nsAString& aMessage) = 0;
 299
 300   virtual nsresult
 301   SendInputMessage(const nsAString& aDeviceAddresses,
 302                    const nsAString& aMessage) = 0;
 303
 304   bool
 305   IsEnabled() const
 306   {
 307     return mEnabled;
 308   }
 309
 310   bool
 311   IsToggling() const;
 312
 313   void FireAdapterStateChanged(bool aEnable);
 314   nsresult EnableDisable(bool aEnable,
 315                          BluetoothReplyRunnable* aRunnable);
 316
 317   /**
 318    * Platform specific startup functions go here. Usually deals with member
 319    * variables, so not static. Guaranteed to be called outside of main thread.
 320    *
 321    * @return NS_OK on correct startup, NS_ERROR_FAILURE otherwise
 322    */
 323   virtual nsresult
 324   StartInternal(BluetoothReplyRunnable* aRunnable) = 0;
 325
 326   /**
 327    * Platform specific startup functions go here. Usually deals with member
 328    * variables, so not static. Guaranteed to be called outside of main thread.
 329    *
 330    * @return NS_OK on correct startup, NS_ERROR_FAILURE otherwise
 331    */
 332   virtual nsresult
 333   StopInternal(BluetoothReplyRunnable* aRunnable) = 0;
 334
 335 protected:
 336   BluetoothService() : mEnabled(false)
 337   { }
 338
 339   virtual ~BluetoothService();
 340
 341   bool
 342   Init();
 343
 344   void
 345   Cleanup();
 346
 347   nsresult
 348   StartBluetooth(bool aIsStartup, BluetoothReplyRunnable* aRunnable);
 349
 350   nsresult
 351   StopBluetooth(bool aIsStartup, BluetoothReplyRunnable* aRunnable);
 352
 353   nsresult
 354   StartStopBluetooth(bool aStart,
 355                      bool aIsStartup,
 356                      BluetoothReplyRunnable* aRunnable);
 357
 358   /**
 359    * Called when XPCOM first creates this service.
 360    */
 361   virtual nsresult
 362   HandleStartup();
 363
 364   /**
 365    * Called when the startup settings check has completed.
 366    */
 367   nsresult
 368   HandleStartupSettingsCheck(bool aEnable);
 369
 370   /**
 371    * Called when "mozsettings-changed" observer topic fires.
 372    */
 373   nsresult
 374   HandleSettingsChanged(const nsAString& aData);
 375
 376   /**
 377    * Called when XPCOM is shutting down.
 378    */
 379   virtual nsresult
 380   HandleShutdown();
 381
 382   // Called by ToggleBtAck.
 383   void
 384   SetEnabled(bool aEnabled);
 385
 386   // Called by Get().
 387   static BluetoothService*
 388   Create();
 389
 390   typedef nsClassHashtable<nsStringHashKey, BluetoothSignalObserverList >
 391   BluetoothSignalObserverTable;
 392
 393   BluetoothSignalObserverTable mBluetoothSignalObserverTable;
 394
 395   bool mEnabled;
 396 };
 397
 398 END_BLUETOOTH_NAMESPACE
 399
 400 #endif