The Tor Browser: dom/bluetooth/BluetoothService.h@6474c204b198 (annotated)

dom/bluetooth/BluetoothService.h@6474c204b198 (annotated)

dom/bluetooth/BluetoothService.h

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
 /* vim: set ts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 #ifndef mozilla_dom_bluetooth_bluetootheventservice_h__
 #define mozilla_dom_bluetooth_bluetootheventservice_h__
 #include "BluetoothCommon.h"
 #include "BluetoothProfileManagerBase.h"
 #include "mozilla/dom/ipc/Blob.h"
 #include "nsAutoPtr.h"
 #include "nsClassHashtable.h"
 #include "nsIDOMFile.h"
 #include "nsIObserver.h"
 #include "nsTObserverArray.h"
 #include "nsThreadUtils.h"
 namespace mozilla {
 namespace ipc {
 class UnixSocketConsumer;
 }
 }
 BEGIN_BLUETOOTH_NAMESPACE
 class BluetoothManager;
 class BluetoothNamedValue;
 class BluetoothReplyRunnable;
 class BluetoothSignal;
 typedef mozilla::ObserverList<BluetoothSignal> BluetoothSignalObserverList;
 class BluetoothService : public nsIObserver
                        , public BluetoothSignalObserver
 {
   class ToggleBtTask;
   friend class ToggleBtTask;
   class StartupTask;
   friend class StartupTask;
 public:
   class ToggleBtAck : public nsRunnable
   {
   public:
     ToggleBtAck(bool aEnabled);
     NS_IMETHOD Run();
   private:
     bool mEnabled;
   };
   friend class ToggleBtAck;
   NS_DECL_ISUPPORTS
   NS_DECL_NSIOBSERVER
   /**
    * Add a message handler object from message distribution observer.
    * Must be called from the main thread.
    *
    * @param aNodeName Node name of the object
    * @param aMsgHandler Weak pointer to the object
    */
   virtual void
   RegisterBluetoothSignalHandler(const nsAString& aNodeName,
                                  BluetoothSignalObserver* aMsgHandler);
   /**
    * Remove a message handler object from message distribution observer.
    * Must be called from the main thread.
    *
    * @param aNodeName Node name of the object
    * @param aMsgHandler Weak pointer to the object
    */
   virtual void
   UnregisterBluetoothSignalHandler(const nsAString& aNodeName,
                                    BluetoothSignalObserver* aMsgHandler);
   /**
    * Remove a message handlers for the given observer.
    * Must be called from the main thread.
    *
    * @param aMsgHandler Weak pointer to the object
    */
   void
   UnregisterAllSignalHandlers(BluetoothSignalObserver* aMsgHandler);
   /**
    * Distribute a signal to the observer list
    *
    * @param aSignal Signal object to distribute
    *
    * @return NS_OK if signal distributed, NS_ERROR_FAILURE on error
    */
   void
   DistributeSignal(const BluetoothSignal& aEvent);
   /**
    * Called when get a Bluetooth Signal from BluetoothDBusService
    *
    */
   void
   Notify(const BluetoothSignal& aParam);
   /**
    * Returns the BluetoothService singleton. Only to be called from main thread.
    *
    * @param aService Pointer to return singleton into.
    *
    * @return NS_OK on proper assignment, NS_ERROR_FAILURE otherwise (if service
    * has not yet been started, for instance)
    */
   static BluetoothService*
   Get();
   static already_AddRefed<BluetoothService>
   FactoryCreate()
   {
     nsRefPtr<BluetoothService> service = Get();
     return service.forget();
   }
   /**
    * Returns the path of the default adapter, implemented via a platform
    * specific method.
    *
    * @return NS_OK on success, NS_ERROR_FAILURE otherwise
    */
   virtual nsresult
   GetDefaultAdapterPathInternal(BluetoothReplyRunnable* aRunnable) = 0;
   /**
    * Returns the properties of paired devices, implemented via a platform
    * specific method.
    *
    * @return NS_OK on success, NS_ERROR_FAILURE otherwise
    */
   virtual nsresult
   GetPairedDevicePropertiesInternal(const nsTArray<nsString>& aDeviceAddresses,
                                     BluetoothReplyRunnable* aRunnable) = 0;
   /**
    * Returns the properties of connected devices regarding to specific profile,
    * implemented via a platform specific methood.
    *
    * @return NS_OK on success, NS_ERROR_FAILURE otherwise
    */
   virtual nsresult
   GetConnectedDevicePropertiesInternal(uint16_t aServiceUuid,
                                        BluetoothReplyRunnable* aRunnable) = 0;
   /**
    * Stop device discovery (platform specific implementation)
    *
    * @return NS_OK if discovery stopped correctly, false otherwise
    */
   virtual nsresult
   StopDiscoveryInternal(BluetoothReplyRunnable* aRunnable) = 0;
   /**
    * Start device discovery (platform specific implementation)
    *
    * @return NS_OK if discovery stopped correctly, false otherwise
    */
   virtual nsresult
   StartDiscoveryInternal(BluetoothReplyRunnable* aRunnable) = 0;
   /**
    * Set a property for the specified object
    *
    * @param aPropName Name of the property
    * @param aValue Boolean value
    * @param aRunnable Runnable to run on async reply
    *
    * @return NS_OK if property is set correctly, NS_ERROR_FAILURE otherwise
    */
   virtual nsresult
   SetProperty(BluetoothObjectType aType,
               const BluetoothNamedValue& aValue,
               BluetoothReplyRunnable* aRunnable) = 0;
   virtual nsresult
   CreatePairedDeviceInternal(const nsAString& aAddress,
                              int aTimeout,
                              BluetoothReplyRunnable* aRunnable) = 0;
   virtual nsresult
   RemoveDeviceInternal(const nsAString& aObjectPath,
                        BluetoothReplyRunnable* aRunnable) = 0;
   /**
    * Get corresponding service channel of specific service on remote device.
    * It's usually the very first step of establishing an outbound connection.
    *
    * @param aObjectPath Object path of remote device
    * @param aServiceUuid UUID of the target service
    * @param aManager Instance which has callback function OnGetServiceChannel()
    *
    * @return NS_OK if the task begins, NS_ERROR_FAILURE otherwise
    */
   virtual nsresult
   GetServiceChannel(const nsAString& aDeviceAddress,
                     const nsAString& aServiceUuid,
                     BluetoothProfileManagerBase* aManager) = 0;
   virtual bool
   UpdateSdpRecords(const nsAString& aDeviceAddress,
                    BluetoothProfileManagerBase* aManager) = 0;
   virtual bool
   SetPinCodeInternal(const nsAString& aDeviceAddress, const nsAString& aPinCode,
                      BluetoothReplyRunnable* aRunnable) = 0;
   virtual bool
   SetPasskeyInternal(const nsAString& aDeviceAddress, uint32_t aPasskey,
                      BluetoothReplyRunnable* aRunnable) = 0;
   virtual bool
   SetPairingConfirmationInternal(const nsAString& aDeviceAddress, bool aConfirm,
                                  BluetoothReplyRunnable* aRunnable) = 0;
   virtual void
   Connect(const nsAString& aDeviceAddress, uint32_t aCod, uint16_t aServiceUuid,
           BluetoothReplyRunnable* aRunnable) = 0;
   virtual void
   Disconnect(const nsAString& aDeviceAddress, uint16_t aServiceUuid,
              BluetoothReplyRunnable* aRunnable) = 0;
   virtual bool
   IsConnected(uint16_t aServiceUuid) = 0;
   virtual void
   SendFile(const nsAString& aDeviceAddress,
            BlobParent* aBlobParent,
            BlobChild* aBlobChild,
            BluetoothReplyRunnable* aRunnable) = 0;
   virtual void
   SendFile(const nsAString& aDeviceAddress,
            nsIDOMBlob* aBlob,
            BluetoothReplyRunnable* aRunnable) = 0;
   virtual void
   StopSendingFile(const nsAString& aDeviceAddress,
                   BluetoothReplyRunnable* aRunnable) = 0;
   virtual void
   ConfirmReceivingFile(const nsAString& aDeviceAddress, bool aConfirm,
                        BluetoothReplyRunnable* aRunnable) = 0;
   virtual void
   ConnectSco(BluetoothReplyRunnable* aRunnable) = 0;
   virtual void
   DisconnectSco(BluetoothReplyRunnable* aRunnable) = 0;
   virtual void
   IsScoConnected(BluetoothReplyRunnable* aRunnable) = 0;
 #ifdef MOZ_B2G_RIL
   virtual void
   AnswerWaitingCall(BluetoothReplyRunnable* aRunnable) = 0;
   virtual void
   IgnoreWaitingCall(BluetoothReplyRunnable* aRunnable) = 0;
   virtual void
   ToggleCalls(BluetoothReplyRunnable* aRunnable) = 0;
 #endif
   virtual void
   SendMetaData(const nsAString& aTitle,
                const nsAString& aArtist,
                const nsAString& aAlbum,
                int64_t aMediaNumber,
                int64_t aTotalMediaCount,
                int64_t aDuration,
                BluetoothReplyRunnable* aRunnable) = 0;
   virtual void
   SendPlayStatus(int64_t aDuration,
                  int64_t aPosition,
                  const nsAString& aPlayStatus,
                  BluetoothReplyRunnable* aRunnable) = 0;
   virtual void
   UpdatePlayStatus(uint32_t aDuration,
                    uint32_t aPosition,
                    ControlPlayStatus aPlayStatus) = 0;
   virtual nsresult
   SendSinkMessage(const nsAString& aDeviceAddresses,
                   const nsAString& aMessage) = 0;
   virtual nsresult
   SendInputMessage(const nsAString& aDeviceAddresses,
                    const nsAString& aMessage) = 0;
   bool
   IsEnabled() const
   {
     return mEnabled;
   }
   bool
   IsToggling() const;
   void
   RemoveObserverFromTable(const nsAString& key);
   /**
    * Below 2 function/variable are used for ensuring event 'AdapterAdded' will
    * be fired after event 'Enabled'.
    */
   void TryFiringAdapterAdded();
   void AdapterAddedReceived();
 protected:
   BluetoothService() : mEnabled(false)
                      , mAdapterAddedReceived(false)
   {
   }
   virtual ~BluetoothService();
   bool
   Init();
   void
   Cleanup();
   nsresult
   StartBluetooth(bool aIsStartup);
   nsresult
   StopBluetooth(bool aIsStartup);
   nsresult
   StartStopBluetooth(bool aStart, bool aIsStartup);
   /**
    * Platform specific startup functions go here. Usually deals with member
    * variables, so not static. Guaranteed to be called outside of main thread.
    *
    * @return NS_OK on correct startup, NS_ERROR_FAILURE otherwise
    */
   virtual nsresult
   StartInternal() = 0;
   /**
    * Platform specific startup functions go here. Usually deals with member
    * variables, so not static. Guaranteed to be called outside of main thread.
    *
    * @return NS_OK on correct startup, NS_ERROR_FAILURE otherwise
    */
   virtual nsresult
   StopInternal() = 0;
   /**
    * Called when XPCOM first creates this service.
    */
   virtual nsresult
   HandleStartup();
   /**
    * Called when the startup settings check has completed.
    */
   nsresult
   HandleStartupSettingsCheck(bool aEnable);
   /**
    * Called when "mozsettings-changed" observer topic fires.
    */
   nsresult
   HandleSettingsChanged(const nsAString& aData);
   /**
    * Called when XPCOM is shutting down.
    */
   virtual nsresult
   HandleShutdown();
   // Called by ToggleBtAck.
   void
   SetEnabled(bool aEnabled);
   // Called by Get().
   static BluetoothService*
   Create();
   typedef nsClassHashtable<nsStringHashKey, BluetoothSignalObserverList >
   BluetoothSignalObserverTable;
   BluetoothSignalObserverTable mBluetoothSignalObserverTable;
   bool mEnabled;
 private:
   bool mAdapterAddedReceived;
 };
 END_BLUETOOTH_NAMESPACE
 #endif

The Tor Browser / annotate

dom/bluetooth/BluetoothService.h@6474c204b198 (annotated)

dom/bluetooth/BluetoothService.h