[CS] 来电处理流程

最新推荐文章于 2022-01-14 19:39:12 发布
最新推荐文章于 2022-01-14 19:39:12 发布
阅读量275 收藏
点赞数
文章标签： java 移动开发 python
原文链接：https://my.oschina.net/igiantpanda/blog/2222412
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

Platform:Android-7.1.1_r22

CS Call来电上报流程

当有来电时，modem会上报CALL_STATE_CHANGED，RIL收到此消息后，会通知GsmCdmaCallTracker进行处理。
由于GsmCdmaCallTracker的构造函数中注册监听call状态改变的事件为EVENT_CALL_STATE_CHANGE，因此RIL上报的call状态改变将会触发EVENT_CALL_STATE_CHANGE事件的处理流程。
GsmCdmaCallTracker.java

public void handleMessage(Message msg) {
......
case EVENT_CALL_STATE_CHANGE:
pollCallsWhenSafe();
......
}

调用父类的方法处理。
通过RIL发起获取当前call的请求。
CallTracker.java
protected void pollCallsWhenSafe() {
mNeedsPoll = true;

if (checkNoOperationsPending()) {
mLastRelevantPoll = obtainMessage(EVENT_POLL_CALLS_RESULT);
mCi.getCurrentCalls(mLastRelevantPoll);
}
}

取得当前call后，继续在GsmCdmaCallTracker中处理。

public void handleMessage(Message msg) {
......
case EVENT_POLL_CALLS_RESULT:
......
handlePollCalls((AsyncResult)msg.obj);
......
}


protected synchronized void handlePollCalls(AsyncResult ar) {
......


for (int i = 0, curDC = 0, dcSize = polledCalls.size()
; i < mConnections.length; i++) {
// 将取得的当前call转换为DriverCall对象
if (curDC < dcSize) {
dc = (DriverCall) polledCalls.get(curDC);
......
}
......
if (conn == null && dc != null) { // 获取到了新的链接
// Connection appeared in CLCC response that we don't know about
if (mPendingMO != null && mPendingMO.compareTo(dc)) {
......
} else {
......
// 新建Connection
mConnections[i] = new GsmCdmaConnection(mPhone, dc, this, i);
......
if (hoConnection != null) {
......
} else {
// find if the MT call is a new ring or unknown connection
newRinging = checkMtFindNewRinging(dc,i); // 判断是来电还是未知链接
if (newRinging == null) {
......
}
}
}
hasNonHangupStateChanged = true;
} else if (conn != null && dc == null) {
......
}
......
if (newRinging != null) { // 通知有新的来电
mPhone.notifyNewRingingConnection(newRinging);
}
......
// 清空所有断开的call
if (newRinging != null || hasNonHangupStateChanged || hasAnyCallDisconnected) {
internalClearDisconnected();
}
......
updatePhoneState(); // 更新Phone状态
......
if (hasNonHangupStateChanged || newRinging != null || hasAnyCallDisconnected) {
mPhone.notifyPreciseCallStateChanged(); // 通知Phone状态变化
}
......
}



~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

先看mPhone.notifyNewRingingConnection(newRinging)的流程
其会通过GsmCdmaPhone → Phone最终通知PstnIncomingCallNotifier处理EVENT_NEW_RINGING_CONNECTION事件。

PstnIncomingCallNotifier.java

private final Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch(msg.what) {
case EVENT_NEW_RINGING_CONNECTION:
handleNewRingingConnection((AsyncResult) msg.obj);
break;
......
}
};

对来电进行一些判断，然后就要准备交给telecom处理。

private void handleNewRingingConnection(AsyncResult asyncResult) {
Log.d(this, "handleNewRingingConnection");
Connection connection = (Connection) asyncResult.result;
if (connection != null) {
Call call = connection.getCall();

// Final verification of the ringing state before sending the intent to Telecom.
if (call != null && call.getState().isRinging()) {
sendIncomingCallIntent(connection);
}
}
}

private void sendIncomingCallIntent(Connection connection) {
// 处理来电显示
Bundle extras = new Bundle();
if (connection.getNumberPresentation() == TelecomManager.PRESENTATION_ALLOWED &&
!TextUtils.isEmpty(connection.getAddress())) {
Uri uri = Uri.fromParts(PhoneAccount.SCHEME_TEL, connection.getAddress(), null);
extras.putParcelable(TelecomManager.EXTRA_INCOMING_CALL_ADDRESS, uri);
}
......
PhoneAccountHandle handle = findCorrectPhoneAccountHandle();
if (handle == null) {
......
} else {
TelecomManager.from(mPhone.getContext()).addNewIncomingCall(handle, extras);
}
}

接下来就通过TelecomManager进入了telecom中，注册新的来电。

TelecomServiceImpl.java

private final ITelecomService.Stub mBinderImpl = new ITelecomService.Stub() {
public void addNewIncomingCall(PhoneAccountHandle phoneAccountHandle, Bundle extras) {
......
mCallIntentProcessorAdapter.processIncomingCallIntent(
mCallsManager, intent);
......
}
}


CallIntentProcessor.java

public static class AdapterImpl implements Adapter {
public void processIncomingCallIntent(CallsManager callsManager, Intent intent) {
CallIntentProcessor.processIncomingCallIntent(callsManager, intent);
}
}

将intent解包，然后再转到CallsManager处理。
static void processIncomingCallIntent(CallsManager callsManager, Intent intent) {
......
callsManager.processIncomingCallIntent(phoneAccountHandle, clientExtras);
}




CallsManager.java

void processIncomingCallIntent(PhoneAccountHandle phoneAccountHandle, Bundle extras) {
......
// 新建Call对象
Call call = new Call(
getNextCallId(),
mContext,
this,
mLock,
mConnectionServiceRepository,
mContactsAsyncHelper,
mCallerInfoAsyncQueryFactory,
mPhoneNumberUtilsAdapter,
handle,
null /* gatewayInfo */,
null /* connectionManagerPhoneAccount */,
phoneAccountHandle,
Call.CALL_DIRECTION_INCOMING /* callDirection */,
false /* forceAttachToExistingConnection */,
false /* isConference */
);

// 初始化CallInfoImpl对象
call.initAnalytics();
......
// 准备建立Connection
call.startCreateConnection(mPhoneAccountRegistrar);
}


开始建立Connection的流程。
com.android.server.telecom.Call.java

void startCreateConnection(PhoneAccountRegistrar phoneAccountRegistrar) {
......
mCreateConnectionProcessor = new CreateConnectionProcessor(this, mRepository, this,
phoneAccountRegistrar, mContext);
mCreateConnectionProcessor.process();
}

从这里开始，建立Connection的准备阶段跟拨号的流程基本相同，因此不再赘述。
从下面开始建立来电Connection的流程就跟去电不一样了。
ConnectionService.java

private void createConnection(
......
boolean isUnknown) {
......
Connection connection = isUnknown ? onCreateUnknownConnection(callManagerAccount, request)
: isIncoming ? onCreateIncomingConnection(callManagerAccount, request)
: onCreateOutgoingConnection(callManagerAccount, request);
......
mAdapter.handleCreateConnectionComplete(
callId,
request,
new ParcelableConnection(
......
connection.getExtras()));
......
}

建立来电Connection。

TelephonyConnectionService.java

public Connection onCreateIncomingConnection(
PhoneAccountHandle connectionManagerPhoneAccount,
ConnectionRequest request) {
......
// 是否为video
int videoState = originalConnection != null ? originalConnection.getVideoState() :
VideoProfile.STATE_AUDIO_ONLY;

Connection connection =
createConnectionFor(phone, originalConnection, false /* isOutgoing */,
request.getAccountHandle(), request.getTelecomCallId(),
request.getAddress(), videoState);
......
}


private TelephonyConnection createConnectionFor(
......
int videoState) {
......
if (phoneType == TelephonyManager.PHONE_TYPE_GSM) {
// 建立Connection
returnConnection = new GsmConnection(originalConnection, telecomCallId);
} else if (phoneType == TelephonyManager.PHONE_TYPE_CDMA) {
......
}
if (returnConnection != null) {
// 监听Connection配置完成的事件，在GsmConnection初始化完成后就会被触发
returnConnection.addTelephonyConnectionListener(mTelephonyConnectionListener);
......
}
......
}

Connection现在就已经建立好了，然后接着看ConnectionService.createConnection()中mAdapter.handleCreateConnectionComplete()的流程。
ConnectionServiceAdapter.java

void handleCreateConnectionComplete(
String id,
ConnectionRequest request,
ParcelableConnection connection) {
for (IConnectionServiceAdapter adapter : mAdapters) {
try {
adapter.handleCreateConnectionComplete(id, request, connection);
} catch (RemoteException e) {
}
}
}

IConnectionServiceAdapter在ConnectionServiceWrapper中进行了实现。
ConnectionServiceWrapper.java

private final class Adapter extends IConnectionServiceAdapter.Stub {

@Override
public void handleCreateConnectionComplete(String callId, ConnectionRequest request,
ParcelableConnection connection) {
......
ConnectionServiceWrapper.this
.handleCreateConnectionComplete(callId, request, connection);
......
}
}
然后又调用ConnectionServiceWrapper的handleCreateConnectionComplete()函数。

private void handleCreateConnectionComplete(
String callId,
ConnectionRequest request,
ParcelableConnection connection) {
......
if (connection.getState() == Connection.STATE_DISCONNECTED) {
......
} else {
if (mPendingResponses.containsKey(callId)) {
mPendingResponses.remove(callId)
.handleCreateConnectionSuccess(mCallIdMapper, connection);
}
}
}

mPendingResponses中的对象为com.android.server.telecom.Call，是在CreateConnectionProcessor.attemptNextPhoneAccount()中通过mService.createConnection(mCall, this)添加到mPendingResponses中的。

com.android.server.telecom.Call.java

public void handleCreateConnectionSuccess(
CallIdMapper idMapper,
ParcelableConnection connection) {
......
switch (mCallDirection) {
case CALL_DIRECTION_INCOMING:
......
for (Listener l : mListeners) {
l.onSuccessfulIncomingCall(this);
}
break;
......
}
}

回调到CallsManager，这里会判断是否阻止来电。
CallsManager.java

public void onSuccessfulIncomingCall(Call incomingCall) {
......
List<IncomingCallFilter.CallFilter> filters = new ArrayList<>();
filters.add(new DirectToVoicemailCallFilter(mCallerInfoLookupHelper));
filters.add(new AsyncBlockCheckFilter(mContext, new BlockCheckerAdapter()));
filters.add(new CallScreeningServiceFilter(mContext, this, mPhoneAccountRegistrar,
mDefaultDialerManagerAdapter,
new ParcelableCallUtils.Converter(), mLock));
new IncomingCallFilter(mContext, this, incomingCall, mLock,
mTimeoutsAdapter, filters).performFiltering();
}

这里用到了3个filter，DirectToVoicemailCallFilter/AsyncBlockCheckFilter/CallScreeningServiceFilter，其中AsyncBlockCheckFilter就是用于黑名单处理的，而DirectToVoicemailCallFilter应该是Voice相关的，CallScreeningServiceFilter不大清楚是干啥的。

IncomingCallFilter.java

public void performFiltering() {
Log.event(mCall, Log.Events.FILTERING_INITIATED);
for (CallFilter filter : mFilters) {
filter.startFilterLookup(mCall, this);
}
......
}

我们这里仅仅看下AsyncBlockCheckFilter的处理流程。
AsyncBlockCheckFilter.java

public void startFilterLookup(Call call, CallFilterResultCallback callback) {
......
this.execute(number);
}

AsyncBlockCheckFilter是一个AsyncTask对象，在doInBackground()中执行给定的任务，其返回的结果将由onPostExecute()处理。

protected Boolean doInBackground(String... params) {
......
return mBlockCheckerAdapter.isBlocked(mContext, params[0]);
......
}

mBlockCheckerAdapter是在CallsManager.onSuccessfulIncomingCall()中新建的BlockCheckerAdapter对象。
BlockCheckerAdapter.java

public boolean isBlocked(Context context, String number) {
return BlockChecker.isBlocked(context, number);
}

最终会通过BlockedNumberProvider来判断来电号码是否在黑名单内，如果在，则返回true。
BlockChecker.java

public static boolean isBlocked(Context context, String phoneNumber) {
......
if (BlockedNumberContract.SystemContract.shouldSystemBlockNumber(
context, phoneNumber)) {
......
isBlocked = true;
}
......
return isBlocked;
}

判断完黑名单后，再转到AsyncBlockCheckFilter.onPostExecute()中处理结果。
根据block的状态创建返回结果，再回调。
AsyncBlockCheckFilter.java

protected void onPostExecute(Boolean isBlocked) {
......
CallFilteringResult result;
if (isBlocked) {
result = new CallFilteringResult(
false, // shouldAllowCall
true, //shouldReject
false, //shouldAddToCallLog
false // shouldShowNotification
);
} else {
result = new CallFilteringResult(
true, // shouldAllowCall
false, // shouldReject
true, // shouldAddToCallLog
true // shouldShowNotification
);
}
......
mCallback.onCallFilteringComplete(mIncomingCall, result);
......
}

回调到IncomingCallFilter。

IncomingCallFilter.java

public void onCallFilteringComplete(Call call, CallFilteringResult result) {
synchronized (mTelecomLock) { // synchronizing to prevent race on mResult
mNumPendingFilters--;
mResult = result.combine(mResult);
if (mNumPendingFilters == 0) {
// synchronized on mTelecomLock to enter into Telecom.
mHandler.post(new Runnable("ICF.oCFC", mTelecomLock) {
@Override
public void loggedRun() {
if (mIsPending) {
Log.event(mCall, Log.Events.FILTERING_COMPLETED, mResult);
mListener.onCallFilteringComplete(mCall, mResult);
mIsPending = false;
}
}
}.prepare());
}
}
}

处理结果时，会把DirectToVoicemailCallFilter/AsyncBlockCheckFilter/CallScreeningServiceFilter的结果进行综合。

CallFilteringResult.java
public CallFilteringResult combine(CallFilteringResult other) {
......
return new CallFilteringResult(
shouldAllowCall && other.shouldAllowCall,
shouldReject || other.shouldReject,
shouldAddToCallLog && other.shouldAddToCallLog,
shouldShowNotification && other.shouldShowNotification);
}

当3个filter都处理完成后，最终又回调到CallsManager。
这里会将Call的状态设置为RINGING，并把Call添加到活动的Call列表中。

CallsManager.java

public void onCallFilteringComplete(Call incomingCall, CallFilteringResult result) {
......
if (incomingCall.getState() != CallState.DISCONNECTED &&
incomingCall.getState() != CallState.DISCONNECTING) {
// 设置Call的状态为RINGING
setCallState(incomingCall, CallState.RINGING,
result.shouldAllowCall ? "successful incoming call" : "blocking call");
} else {
......
}

if (result.shouldAllowCall) {
if (hasMaximumRingingCalls()) {
......
} else if (hasMaximumDialingCalls()) {
......
} else {
addCall(incomingCall);
}
} else {
......
}
}

private void addCall(Call call) {
......
// 为Call设置listener，并添加到Call的集合中
call.addListener(this);
mCalls.add(call);
......
for (CallsManagerListener listener : mListeners) {
......
listener.onCallAdded(call);
......
}
......
}

未完待续......

添加call后，会回调InCallController.onCallAdded(),InCallController是在CallsManager的构造函数中初始化并添加到listener中的。

InCallController.java
public void onCallAdded(Call call) {
......
addCall(call); // InCallController中也会跟踪call
......
for (Map.Entry<InCallServiceInfo, IInCallService> entry : mInCallServices.entrySet()) {
......
inCallService.addCall(parcelableCall); // AIDL调用InCallServiceBinder
......
}
......
}

InCallServiceBinder.addCall()中未做任何处理，直接发送MSG_ADD_CALL消息给InCallService的Handler处理。

InCallService.java

private final class InCallServiceBinder extends IInCallService.Stub {
public void addCall(ParcelableCall call) {
mHandler.obtainMessage(MSG_ADD_CALL, call).sendToTarget();
}
}


private final Handler mHandler = new Handler(Looper.getMainLooper()) {
@Override
public void handleMessage(Message msg) {
......
switch (msg.what) {
......
case MSG_ADD_CALL:
mPhone.internalAddCall((ParcelableCall) msg.obj); // 到android.telecom.Phone中进行处理
break;
......
}

注意，此Phone并非frameworks/opt/telephony中的Phone对象。
Phone中会把传入的ParcelableCall转换为android.telecom.Call对象进行保存，然后又通过InCallService中的mPhoneListener回调到onCallAdded()。
android.telecom.Phone.java

final void internalAddCall(ParcelableCall parcelableCall) {
Call call = new Call(this, parcelableCall.getId(), mInCallAdapter,
parcelableCall.getState());
mCallByTelecomCallId.put(parcelableCall.getId(), call);
mCalls.add(call);
checkCallTree(parcelableCall);
call.internalUpdate(parcelableCall, mCallByTelecomCallId);
fireCallAdded(call);
}

private void fireCallAdded(Call call) {
for (Listener listener : mListeners) {
listener.onCallAdded(this, call);
}
}

InCallService.onCallAdded()的具体实现在其子类InCallServiceImpl中。
InCallServiceImpl.java

public void onCallAdded(Call call) {
InCallPresenter.getInstance().onCallAdded(call);
}


将Call添加到CallList。
InCallPresenter.java

public void onCallAdded(final android.telecom.Call call) {
......
mCallList.onCallAdded(call);
......
}

对于来电，call状态当然是INCOMING，因此调用onIncoming()。
CallList.java

public void onCallAdded(final android.telecom.Call telecomCall) {
......
if (call.getState() == Call.State.INCOMING ||
call.getState() == Call.State.CALL_WAITING) {
onIncoming(call, call.getCannedSmsResponses());
} else {
onUpdate(call);
}
......
}

onIncoming()又回调到InCallPresenter。
public void onIncoming(Call call, List<String> textMessages) {
......
for (Listener listener : mListeners) {
listener.onIncomingCall(call);
}
}


调用startOrFinishUi()，最终启动来电界面。具体过程就略过了。
InCallPresenter.java

public void onIncomingCall(Call call) {
InCallState newState = startOrFinishUi(InCallState.INCOMING);
InCallState oldState = mInCallState;

Log.i(this, "Phone switching state: " + oldState + " -> " + newState);
mInCallState = newState;

for (IncomingCallListener listener : mIncomingCallListeners) {
listener.onIncomingCall(oldState, mInCallState, call);
}
}



















~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


GsmCdmaCallTracker.handlePollCalls()中调用updatePhoneState()

private void updatePhoneState() {
PhoneConstants.State oldState = mState;
if (mRingingCall.isRinging()) {
mState = PhoneConstants.State.RINGING;
} else if (mPendingMO != null ||
......

if (mState == PhoneConstants.State.IDLE && oldState != mState) {
mVoiceCallEndedRegistrants.notifyRegistrants(
new AsyncResult(null, null, null));
} else if (oldState == PhoneConstants.State.IDLE && oldState != mState) {
// 通知相关监听者Call已经建立起来了
mVoiceCallStartedRegistrants.notifyRegistrants (
new AsyncResult(null, null, null));
}
......
if (mState != oldState) {
// 通知Phone状态变化
mPhone.notifyPhoneStateChanged();
TelephonyMetrics.getInstance().writePhoneState(mPhone.getPhoneId(), mState);
}
}


notifyPhoneStateChanged()会通过GsmCdmaPhone → DefaultPhoneNotifier最终通知到TelephonyRegistry。

TelephonyRegistry.java
public void notifyCallStateForPhoneId(int phoneId, int subId, int state,
String incomingNumber) {
......
// 回调监听了LISTEN_CALL_STATE事件的listener
r.callback.onCallStateChanged(state, incomingNumberOrEmpty);
......
broadcastCallStateChanged(state, incomingNumber, phoneId, subId);
}















 

转载于:https://my.oschina.net/igiantpanda/blog/2222412

weixin_34005042
关注
androoid framework学习之 - Telephony 来电流程
happyguys12345的博客
01-12 660
androoid framework学习之 - Telephony 来电流程 今天顺了一下来电的整个流程，从RIL开始捋一捋： 1.在RIL.java中：当moderm有新信息通过Socket发送过来时，RIL Receive会接收到，然后跑processResponse。  class RILReceiver implements Runnable {
安卓10拨号流程详细总结
mike_jungle的博客
12-02 6626
packages/apps/Dialer/java/com/android/dialer/dialpadview/DialpadFragment.java 用户点击拨号盘的拨号按钮，此时开始呼叫长征第一步，dialpadfragment的onclick方法会响应点击事件。 @Override public void onClick(View view) { int resId = view.getId(); if (resId == R.id.dialpad_float...
[CS] 拨号流程
weixin_34321977的博客
10-02 426
2019独角兽企业重金招聘Python工程师标准>>> ...
TDSCDMA CS呼叫流程
bird67的专栏
08-23 1711
以时序的形式展现TD-SCDMA CS呼叫的整个流程：  1. 主叫：RRC连接建立；初始直传；鉴权和安全模式；  2. 主叫：Setup--->核心网；（表示主叫方发了一条Setup信令给核心网，下同）  3. 主叫：核心网--->CallProc
cs call
贱贱的杨 blog
06-15 1548
cs call (Android 7)dialer 进程 点击拨号 触发拨号处理 com.android.dialer.dialpad.DialpadFragment#handleDialButtonPressed private void handleDialButtonPressed() { if (isDigitsEmpty()) { // No number entered.
来电流程
carywei的专栏
11-09 119
Arm9 来电要共分为两个消息：CM_CALL_EVENT_INCOM和CM_CALL_EVENT_SETUP_IND 对UTMS手机，系统先上报：CM_CALL_EVENT_SETUP_IND,之后上报CM_CALL_EVENT_INCOM. CM_CALL_EVENT_INCOM 会传送arm11测，触发new_connection CM_CALL_EVENT_SETUP_IND则会先把...
cs信令流程_中兴_cs信令流程
03-09
2. **移动呼叫业务**：主要处理语音呼叫的建立、维护和释放流程，包括拨打、接听和挂断电话等操作。 3. **短消息业务**：负责短消息的发送、接收以及状态报告等功能，是移动通信中最基本的服务之一。 4. **补充...
tdscdma语音业务完整呼叫流程
11-26
TD-SCDMA（Time Division Synchronous Code Division Multiple Access，时分同步码分多址）是中国主导的3G移动通信标准，它在语音业务处理方面有着一套严谨的呼叫流程。这个流程涉及多个网络实体间的交互，包括移动...
WCDMA主要信令流程
03-07
MMS业务流程包括消息的创建、发送、接收及处理。 **4.5 STREAMING** - **基于H.324的流媒体业务**：支持低带宽条件下的音频和视频传输。 - **基于H.323的流媒体业务**：适用于更高带宽环境下的多媒体通信。 - **...
通信\WCDMA主要信令流程
05-21
在被叫流程中，UE接收到来电并回应；CS64K可视电话服务则涉及视频与音频的同步传输，若遇到不支持的情况，系统可能进行话音回落。 3. PS（Packet Switched，分组交换）基本业务流程： 分组域主要处理数据流量，如...
CSCall++:Clib 和系统调用的 C++ 接口-开源
05-30
A C++ library genuinely for system programming by wrapping commonly used system calls and C library functions into forms appropriate in C++ context for system programming. The API is designed fool-proof, application normally just use it mechanically, not many rule/names invented to remember. 真正的系統程式設計程式庫: 轉換底層的系統呼叫及C-lib界面至較統一且適用於C++語境下的系統程式界面規則. 使用者一般來說並不需要深度了解C++標準程式庫 因爲C++標準程式庫的語義實際上是超乎尋常的複雜 且大多針對有限的"標準"(內定)作業.
CS基本业务流程
01-31
位置更新 呼叫流程等详细的过程,请需要的参考一下
GSM下的Basic call（CS）
u011517635的博客
12-13 319
This page is based on a call processing sequence between an MS and GSM Network Simulator. The details of the sequence and contents of the messages would differ from those from live network, but I thin...
FFOS cs call
贱贱的杨 blog
06-12 1215
firefox OS cs call 流程
CobaltStrike逆向学习系列(1)：CS 登陆通信流程分析
无心的博客
01-14 462
这是[信安成长计划]的第 1 篇文章 关注微信公众号[信安成长计划] 0x00 目录 0x01 密码校验 0x02 aggressor.authenticate 0x03 aggressor.metadata 0x04 数据同步 0x05 流程图 0x06 参考文章 先统一一下后续文章所提到的一些名词，以确保大家都在聊同一个东西，文中将 CobaltStrike分为 Controller、TeamServer、Beacon 三端，本文所描述的是 TeamServer 启动之后，从 Controller 登
Android IMS 通话应用设计
好记性不如写博客！
02-14 2512
背景 以下内容基于Android P code。 应用框架设计 Android电话模块是一个典型的分层结构设计，如下： 分层结构 IMS在CS通话的基础上增加了telephony/ims net/ims vendor/ims 和ims相关的media模块。 其中： telephony/ims：主要包括了对外接口ImsPhone，通话管理中心ImsPhoneCallTracker，...
android Telephony学习 --- 第七篇 android7.0 来电(MT)流程
tingsky9985的博客
09-28 1058
我们先看下7.0来电大体流程： ##Framework modem接收到来电通知消息后，以AT指令的方式上报RIL层，RIL层通过sokcet将消息发送给RILJ， 上报事件ID: RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED： frameworks/opt/telephony – RIL 　private void　processUnsolicited ...
Android7.0 Phone应用源码分析（二） phone来电流程分析
weixin_30627341的博客
11-06 320
接上篇博文:Android7.0 Phone应用源码分析（一） phone拨号流程分析 今天我们再来分析下Android7.0 的phone的来电流程 1.1TelephonyFramework 当有来电通知时，首先接收到消息的是Modem层，然后Medoem再上传给RIL层，RIL进程通过sokcet将消息发送给RILJ（framework层的RIL），同样进入RILJ的process...
ringtone分析（二）
kwinters的专栏
11-19 4831
public final class RingtonePickerActivity extends AlertActivity implements AdapterView.OnItemSelectedListener, Runnable, DialogInterface.OnClickListener, AlertController.AlertParams.On
卫星图像处理流程详解
卫星图像处理流程 卫星图像处理是遥感技术中的一种重要过程，它包括图像预处理、几何纠正、radiometric correction等多个步骤。以下是卫星图像处理流程的详细介绍： 一、图像预处理 图像预处理是卫星图像处理的第...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值