<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">

	<head>
		<meta name="copyright" content="Copyright &copy; 2014 The Eclipse Foundation. All Rights Reserved." />
		<meta http-equiv="content-type" content="text/html;charset=ISO-8859-1" />
		<meta http-equiv="Content-Style-Type" content="text/css" />

		<title>Capella - In-Flight Entertainment System - Capability Provide Satellite and Internal Telephony Services</title>
		<link rel="stylesheet" href="../../scripts/jquery-treeview/jquery.treeview.css" />
  		<script src="../../scripts/jquery-treeview/lib/jquery-1.11.1.js" type="text/javascript"></script>
  		<script src="../../scripts/jquery-treeview/jquery.treeview.js" type="text/javascript"></script>
		<link rel="stylesheet" type="text/css" href="../../css/simpletree.css" />		
		<link title="default" rel="stylesheet" type="text/css" media="screen, projection" href="../../css/content.css"></link>
		<script type="text/javascript">
			if(parent.location.href == self.location.href) {
				window.location.href = 'index.html?432070981d884680ae1468f165e74c24';
			}
		</script>
		
		<style>
			body {
				background: white;
				font-family: Arial;
			}
			.treeview {
				background-color: white ;
			}
	
			.treeview ul{ /*CSS for Simple Tree Menu*/
				background-color: white;
				font-size: 12px;
			}
	
			.treeview li{ /*Style for LI elements in general (excludes an LI that contains sub lists)*/
				background-color: white;
			}
		</style>
		
	</head>
	
	<body>	<div id="content">
<img src="../icon/Capability.png" alt="Capability" style="float:left; margin-right:10px" /><h1><a href="../In-Flight Entertainment System/432070981d884680ae1468f165e74c24.html">Provide Satellite and Internal Telephony Services</a></h1>
<p style="margin-top:3px; margin-bottom:3px"><span class="elementMetaClass">Capability</span></p>
<em class="elementPath"><a href="../In-Flight Entertainment System/bd182435e29042ceb99f6dd06e7ae7c7.html">In&#045;Flight Entertainment System</a> > <a href="../In-Flight Entertainment System/8f49452e61f24ba0b944352d1f4c4227.html">In&#045;Flight Entertainment System</a> > <a href="../In-Flight Entertainment System/1d30b780f22247949f785b70ce799bf0.html">System Analysis</a> > <a href="../In-Flight Entertainment System/7fdc15cd094b4f7cbd926c8d001fb5e7.html">Capabilities</a> > <a href="../In-Flight Entertainment System/432070981d884680ae1468f165e74c24.html">Provide Satellite and Internal Telephony Services</a></em>

<p>

[Wikipedia]<br />
Some airlines provide satellite telephones integrated into their system. These are either found at strategic locations in
the aircraft or integrated into the passenger remote control used for the individual in-flight entertainment. Passengers
can use their credit card to make phone calls anywhere on the ground. These systems are usually not capable of receiving
incoming calls. There are also some aircraft that allow faxes to be sent and the rate is usually the same as the call rate,
but at a per page rate. Some systems also allow the transmission of SMS. More modern systems allow passengers to call
fellow passengers located in another seat by simply keying in the recipient's seat number.
</p>













<h2>Exploiting Missions</h2>
<ul class="generatedList"><li><img src="../icon/Mission.gif" alt="Mission" /> <a href="../In-Flight Entertainment System/e9691a8530a64b72842db0e59ca2a104.html">Provide Connectivity Solutions</a></li></ul>

<h2>Involved Actors</h2>
<ul class="generatedList"><li><img src="../icon/SystemActorHuman.gif" alt="SystemComponent" /> <a href="../In-Flight Entertainment System/181a678cdca946c19d18b5a0c457c0de.html">Passenger</a></li><li><img src="../icon/SystemActorHuman.gif" alt="SystemComponent" /> <a href="../In-Flight Entertainment System/c8b78c785b114fc087b73ca84622efea.html">Aircraft</a></li></ul>




<h2>Realizing Elements </h2>

<ul class="generatedList"><li><img src="../icon/CapabilityRealization.gif" alt="CapabilityRealization" /> <a href="../In-Flight Entertainment System/5c8adc1c079e4cad9b334dfb53db7f66.html">Provide Satellite and Internal Telephony Services</a></li></ul>








<h2>Diagrams displaying "Provide Satellite and Internal Telephony Services"</h2>
<ul>
<li>
<a href="../In-Flight Entertainment System/7fdc15cd094b4f7cbd926c8d001fb5e7.html#_Q3xl4JTyEeSgObsjQ4XNVQ">&#091;MCB&#093; All Missions and Capabilities</a> 
</li>
</ul>





 </div>	</body>
</html>
