WebAPI/WebTelephony: Difference between revisions

From MozillaWiki
Jump to navigation Jump to search
(Proposal (v2): telephony call states to support call holding)
(Proposal (v2): telephony call states to support call holding)
Line 5: Line 5:
navigator.telephony would return an object with the following interface  
navigator.telephony would return an object with the following interface  


  interface Telephony : EventTarget {
  interface Telephony : EventTarget {
  TelephonyCall dial(DOMString number); // Returns a object in "dialing" state
  TelephonyCall dial(DOMString number); // Returns a object in "dialing" state
  attribute boolean muted;          // Should these live on the call/group?
  attribute boolean muted;          // Should these live on the call/group?
  attribute boolean speakerEnabled;
  attribute boolean speakerEnabled;
    
  attribute any active; // Active call, for now. Could be a group in the future.
   attribute any active; // Active call, for now. Could be a group in the future.
    
  readonly attribute TelephonyCall[] calls;
   readonly attribute TelephonyCall[] calls;
    
  void startTone(DOMString tone);
   void startTone(DOMString tone);
  void stopTone();
  void stopTone();
    
  attribute Function onincoming;
   attribute Function onincoming;
  attribute Function oncallschanged;
  attribute Function oncallschanged;
  }
  }
 
  interface TelephonyCall : EventTarget {
  interface TelephonyCall : EventTarget {
  readonly attribute DOMString number;
  readonly attribute DOMString number;
    
  readonly attribute DOMString state;
   readonly attribute DOMString state;
  // "dialing", "ringing", "busy", "connecting", "connected", "disconnecting", "disconnected", "incoming"
  // "dialing", "ringing", "busy", "connecting", "connected", "disconnecting", "disconnected", "incoming"
    
  attribute Function onstatechange;
   attribute Function onstatechange;
  attribute Function onringing;
  attribute Function onringing;
  attribute Function onbusy;
  attribute Function onbusy;
  attribute Function onconnecting;
  attribute Function onconnecting;
  attribute Function onconnected;
  attribute Function onconnected;
  attribute Function ondisconnecting;
  attribute Function ondisconnecting;
  attribute Function ondisconnected;
  attribute Function ondisconnected;
    
  void answer(); // Should this make the call the active one?
   void answer(); // Should this make the call the active one?
  void hangUp();
  void hangUp();
  }
  }
 
  interface CallEvent : Event {
  interface CallEvent : Event {
  readonly attribute TelephonyCall call;
  readonly attribute TelephonyCall call;
  }
  }
<h3> Proposal: Enhance telephony call states to hold a call  </h3>
 
<p>The diagram below shows the current design of B2G telephony call states (white blocks) and the proposal for holding a call (yellow blocks).  
=== Proposal: Enhance telephony call states to hold a call  ===
</p><p><br />
 
</p><p>&#160;State transition in detail:
The diagram below shows the current design of B2G telephony call states (white blocks) and the proposal for holding a call (yellow blocks).  
</p>
 
<ul><li>Scenario #1: There is no other call on-line (current design)<br />When a remote party dials, a new call is generated with its call index (no. 1), and the call state now is CALL_STATE_INCOMING.<br />When user answers/hangs up the call, the call state is eventually pushed to CALL_STATE_CONNECTED/CALL_STATE_DISCONNECTED according to user's decision.  
<br>  
</li><li>Scenario #2: There is already a call on-line<br />When the third party dials, a new call is generated with the state of CALL_STATE_INCOMING. Since there is already a call on-line, the new call's index is no. 2. When user answers the new call (call no. 2), its state is going to be transferred to CALL_STATE_CONNECTED. In the meanwhile, the state of the originally connected call (call no. 1) should be forced to CALL_STATE_HELD. <br />
 
</li><li>Scenario #3: User wants to hold a call when there's no waiting call<br />User can |HoldCall()| to change the call state from CALL_STATE_CONNECTED to CALL_STATE_HELD. User can |ResumeCall()| to make a call from CALL_STATE_HELD back to <br />CALL_STATE_CONNECTED.
&nbsp;State transition in detail:  
</li></ul>
 
<p>&#160;<img src="/images/thumb/b/b9/Proposal_TelephonyCallStates_v2.png/777px-Proposal_TelephonyCallStates_v2.png" _fck_mw_filename="Proposal TelephonyCallStates v2.png" _fck_mw_width="778" _fck_mw_height="865" alt="Proposal of telephony call states to support call holding" /><br />
*Scenario #1: There is no other call on-line (current design)<br>When a remote party dials, a new call is generated with its call index (no. 1), and the call state now is CALL_STATE_INCOMING.<br>When user answers/hangs up the call, the call state is eventually pushed to CALL_STATE_CONNECTED/CALL_STATE_DISCONNECTED according to user's decision.  
</p>
*Scenario #2: There is already a call on-line<br>When the third party dials, a new call is generated with the state of CALL_STATE_INCOMING. Since there is already a call on-line, the new call's index is no. 2. When user answers the new call (call no. 2), its state is going to be transferred to CALL_STATE_CONNECTED. In the meanwhile, the state of the originally connected call (call no. 1) should be forced to CALL_STATE_HELD. <br>  
*Scenario #3: User wants to hold a call when there's no waiting call<br>User can |HoldCall()| to change the call state from CALL_STATE_CONNECTED to CALL_STATE_HELD. User can |ResumeCall()| to make a call from CALL_STATE_HELD back to <br>CALL_STATE_CONNECTED.
 
&nbsp;[[Image:Proposal_TelephonyCallStates_v2.png|842x936px|Proposal of telephony call states to support call holding]]<br>  


=== Proposal: Enhance WebTelephony API to hold a call  ===
=== Proposal: Enhance WebTelephony API to hold a call  ===
Line 58: Line 61:
   interface nsIDOMTelephony&nbsp;: nsIDOMEventTarget
   interface nsIDOMTelephony&nbsp;: nsIDOMEventTarget
  {
  {
  nsIDOMTelephonyCall dial(in DOMString number);
  nsIDOMTelephonyCall dial(in DOMString number);
    
  attribute boolean muted;
   attribute boolean muted;
  attribute boolean speakerEnabled;
  attribute boolean speakerEnabled;
    
  // The call that is "active", i.e. receives microphone input and tones
   // The call that is "active", i.e. receives microphone input and tones
  // generated via startTone.
  // generated via startTone.
  readonly attribute jsval active;
  readonly attribute jsval active;
    
  // Array of all calls that are currently connected.
   // Array of all calls that are currently connected.
  readonly attribute jsval calls;
  readonly attribute jsval calls;
    
  void startTone(in DOMString tone);
   void startTone(in DOMString tone);
  void stopTone();
  void stopTone();
    
  attribute nsIDOMEventListener onincoming;
   attribute nsIDOMEventListener onincoming;
  attribute nsIDOMEventListener oncallschanged;
  attribute nsIDOMEventListener oncallschanged;
  };
  };
 
  interface nsIDOMTelephonyCall&nbsp;: nsIDOMEventTarget
  interface nsIDOMTelephonyCall&nbsp;: nsIDOMEventTarget
  {
  {
  readonly attribute DOMString number;
  readonly attribute DOMString number;
 
 
  // "dialing", "ringing", "busy", "connecting", "connected", "disconnecting", "disconnected", "incoming"
  // "dialing", "ringing", "busy", "connecting", "connected", "disconnecting", "disconnected", "incoming"
  // Add new states: "holding", "held", "resuming"
  // Add new states: "holding", "held", "resuming"
  readonly attribute DOMString state;
  readonly attribute DOMString state;
   
   
  void answer();   
  void answer();   
  void hangUp();
  void hangUp();
 
  //make a "connected" call into "held"
  void holdCall();
  //make a "held" call back to "connected"
  void resumeCall();  
    
    
  attribute nsIDOMEventListener onstatechange;
  //make a "connected" call into "held"
    
  void holdCall();
  attribute nsIDOMEventListener ondialing;
  //make a "held" call back to "connected"
  attribute nsIDOMEventListener onringing;
  void resumeCall();
  attribute nsIDOMEventListener onbusy;
  attribute nsIDOMEventListener onconnecting;
  attribute nsIDOMEventListener onstatechange;
  attribute nsIDOMEventListener onconnected;
  attribute nsIDOMEventListener ondisconnecting;
   attribute nsIDOMEventListener ondialing;
  attribute nsIDOMEventListener ondisconnected;
  attribute nsIDOMEventListener onringing;
    
  attribute nsIDOMEventListener onbusy;
  // attribute nsIDOMEventListener onincoming;
  attribute nsIDOMEventListener onconnecting;
  /* new events */
  attribute nsIDOMEventListener onconnected;
  attribute nsIDOMEventListener onholding;  
  attribute nsIDOMEventListener ondisconnecting;
  attribute nsIDOMEventListener onheld;  
  attribute nsIDOMEventListener ondisconnected;
  attribute nsIDOMEventListener onresuming;  
   // attribute nsIDOMEventListener onincoming;
  /* new events */
  attribute nsIDOMEventListener onholding;  
  attribute nsIDOMEventListener onheld;  
  attribute nsIDOMEventListener onresuming;  
  };
  };

Revision as of 05:03, 22 March 2012

Proposed API

(lkcl29dec11: remember also to include data calls as well as voice calls, so that internet access can be initiated)

navigator.telephony would return an object with the following interface

interface Telephony : EventTarget {
 TelephonyCall dial(DOMString number); // Returns a object in "dialing" state
 attribute boolean muted;           // Should these live on the call/group?
 attribute boolean speakerEnabled;

 attribute any active; // Active call, for now. Could be a group in the future.

 readonly attribute TelephonyCall[] calls;

 void startTone(DOMString tone);
 void stopTone();

 attribute Function onincoming;
 attribute Function oncallschanged;
}

interface TelephonyCall : EventTarget {
 readonly attribute DOMString number;

 readonly attribute DOMString state;
 // "dialing", "ringing", "busy", "connecting", "connected", "disconnecting", "disconnected", "incoming"

 attribute Function onstatechange;
 attribute Function onringing;
 attribute Function onbusy;
 attribute Function onconnecting;
 attribute Function onconnected;
 attribute Function ondisconnecting;
 attribute Function ondisconnected;

 void answer(); // Should this make the call the active one?
 void hangUp();
}

interface CallEvent : Event {
 readonly attribute TelephonyCall call;
}

Proposal: Enhance telephony call states to hold a call

The diagram below shows the current design of B2G telephony call states (white blocks) and the proposal for holding a call (yellow blocks).


 State transition in detail:

  • Scenario #1: There is no other call on-line (current design)
    When a remote party dials, a new call is generated with its call index (no. 1), and the call state now is CALL_STATE_INCOMING.
    When user answers/hangs up the call, the call state is eventually pushed to CALL_STATE_CONNECTED/CALL_STATE_DISCONNECTED according to user's decision.
  • Scenario #2: There is already a call on-line
    When the third party dials, a new call is generated with the state of CALL_STATE_INCOMING. Since there is already a call on-line, the new call's index is no. 2. When user answers the new call (call no. 2), its state is going to be transferred to CALL_STATE_CONNECTED. In the meanwhile, the state of the originally connected call (call no. 1) should be forced to CALL_STATE_HELD.
  • Scenario #3: User wants to hold a call when there's no waiting call
    User can |HoldCall()| to change the call state from CALL_STATE_CONNECTED to CALL_STATE_HELD. User can |ResumeCall()| to make a call from CALL_STATE_HELD back to
    CALL_STATE_CONNECTED.

 Proposal of telephony call states to support call holding

Proposal: Enhance WebTelephony API to hold a call

 interface nsIDOMTelephony : nsIDOMEventTarget
{
 nsIDOMTelephonyCall dial(in DOMString number);

 attribute boolean muted;
 attribute boolean speakerEnabled;

 // The call that is "active", i.e. receives microphone input and tones
 // generated via startTone.
 readonly attribute jsval active;

 // Array of all calls that are currently connected.
 readonly attribute jsval calls;

 void startTone(in DOMString tone);
 void stopTone();

 attribute nsIDOMEventListener onincoming;
 attribute nsIDOMEventListener oncallschanged;
};

interface nsIDOMTelephonyCall : nsIDOMEventTarget
{
 readonly attribute DOMString number;
 
 // "dialing", "ringing", "busy", "connecting", "connected", "disconnecting", "disconnected", "incoming"
 // Add new states: "holding", "held", "resuming"
 readonly attribute DOMString state;

 void answer();  
 void hangUp();
 
 //make a "connected" call into "held"
 void holdCall(); 
 //make a "held" call back to "connected"
 void resumeCall(); 

 attribute nsIDOMEventListener onstatechange;

 attribute nsIDOMEventListener ondialing;
 attribute nsIDOMEventListener onringing;
 attribute nsIDOMEventListener onbusy;
 attribute nsIDOMEventListener onconnecting;
 attribute nsIDOMEventListener onconnected;
 attribute nsIDOMEventListener ondisconnecting;
 attribute nsIDOMEventListener ondisconnected;

 // attribute nsIDOMEventListener onincoming;
 /* new events */
 attribute nsIDOMEventListener onholding; 
 attribute nsIDOMEventListener onheld; 
 attribute nsIDOMEventListener onresuming; 
};