openharmony/telephony_core_service
1
0
Fork 0
mirror of https://gitee.com/openharmony/telephony_core_service synced 2024-11-23 16:09:48 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

log

Browse Source 
Signed-off-by: w00636648 <wangziming14@huawei.com>
This commit is contained in:
w00636648 2023-03-14 12:24:48 +08:00
parent 643da0ec82
commit 2540e4b7bf
20 changed files with 195 additions and 196 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

92
services/core/src/core_service.cpp
View File

@ -294,7 +294,7 @@ int32_t CoreService::GetNrOptionMode(int32_t slotId, NrMode &mode)
int32_t CoreService::HasSimCard(int32_t slotId, bool &hasSimCard)
{
TELEPHONY_LOGI("CoreService::HasSimCard(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::HasSimCard(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -304,7 +304,7 @@ int32_t CoreService::HasSimCard(int32_t slotId, bool &hasSimCard)
int32_t CoreService::GetSimState(int32_t slotId, SimState &simState)
{
TELEPHONY_LOGI("CoreService::GetSimState(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::GetSimState(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -315,7 +315,7 @@ int32_t CoreService::GetSimState(int32_t slotId, SimState &simState)
int32_t CoreService::GetCardType(int32_t slotId, CardType &cardType)
{
TELEPHONY_LOGI("CoreService::GetCardType(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::GetCardType(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -326,7 +326,7 @@ int32_t CoreService::GetCardType(int32_t slotId, CardType &cardType)
int32_t CoreService::GetISOCountryCodeForSim(int32_t slotId, std::u16string &countryCode)
{
TELEPHONY_LOGI("CoreService::GetISOCountryCodeForSim(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::GetISOCountryCodeForSim(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -337,7 +337,7 @@ int32_t CoreService::GetISOCountryCodeForSim(int32_t slotId, std::u16string &cou
int32_t CoreService::GetSimSpn(int32_t slotId, std::u16string &spn)
{
TELEPHONY_LOGI("CoreService::GetSimSpn(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::GetSimSpn(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -351,7 +351,7 @@ int32_t CoreService::GetSimIccId(int32_t slotId, std::u16string &iccId)
TELEPHONY_LOGE("permission denied!");
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::GetSimIccId(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::GetSimIccId(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -361,7 +361,7 @@ int32_t CoreService::GetSimIccId(int32_t slotId, std::u16string &iccId)
int32_t CoreService::GetSimOperatorNumeric(int32_t slotId, std::u16string &operatorNumeric)
{
TELEPHONY_LOGI("CoreService::GetSimOperatorNumeric(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::GetSimOperatorNumeric(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -375,7 +375,7 @@ int32_t CoreService::GetIMSI(int32_t slotId, std::u16string &imsi)
TELEPHONY_LOGE("permission denied!");
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::GetIMSI(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::GetIMSI(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -385,7 +385,7 @@ int32_t CoreService::GetIMSI(int32_t slotId, std::u16string &imsi)
bool CoreService::IsSimActive(int32_t slotId)
{
TELEPHONY_LOGI("CoreService::IsSimActive(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::IsSimActive(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return false;
@ -395,7 +395,7 @@ bool CoreService::IsSimActive(int32_t slotId)
int32_t CoreService::GetSlotId(int32_t simId)
{
TELEPHONY_LOGI("CoreService::GetSlotId(), simId = %{public}d", simId);
TELEPHONY_LOGD("CoreService::GetSlotId(), simId = %{public}d", simId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("CoreService::GetSlotId(), simManager_ is nullptr!");
return TELEPHONY_ERROR;
@ -405,7 +405,7 @@ int32_t CoreService::GetSlotId(int32_t simId)
int32_t CoreService::GetSimId(int32_t slotId)
{
TELEPHONY_LOGI("CoreService::GetSimId(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::GetSimId(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("CoreService::GetSimId(), simManager_ is nullptr!");
return TELEPHONY_ERROR;
@ -441,7 +441,7 @@ std::u16string CoreService::GetLocaleFromDefaultSim()
TELEPHONY_LOGE("CoreService::GetLocaleFromDefaultSim, Permission denied!");
return std::u16string();
}
TELEPHONY_LOGI("CoreService::GetSimAccountInfo()");
TELEPHONY_LOGD("CoreService::GetLocaleFromDefaultSim()");
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return std::u16string();
@ -460,7 +460,7 @@ int32_t CoreService::GetSimGid1(int32_t slotId, std::u16string &gid1)
TELEPHONY_LOGE("CoreService::GetSimGid1, Permission denied!");
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::GetSimGid1(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::GetSimGid1(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -474,7 +474,7 @@ std::u16string CoreService::GetSimGid2(int32_t slotId)
TELEPHONY_LOGE("CoreService::GetSimGid2, Permission denied!");
return std::u16string();
}
TELEPHONY_LOGI("CoreService::GetSimGid2(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::GetSimGid2(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return std::u16string();
@ -484,7 +484,7 @@ std::u16string CoreService::GetSimGid2(int32_t slotId)
std::u16string CoreService::GetSimEons(int32_t slotId, const std::string &plmn, int32_t lac, bool longNameRequired)
{
TELEPHONY_LOGI("CoreService::GetSimEons(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::GetSimEons(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("CoreService::GetSimEons, Permission denied!");
return std::u16string();
@ -498,7 +498,7 @@ int32_t CoreService::GetSimAccountInfo(int32_t slotId, IccAccountInfo &info)
TELEPHONY_LOGE("permission denied!");
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::GetSimAccountInfo(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::GetSimAccountInfo(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -512,7 +512,7 @@ int32_t CoreService::SetDefaultVoiceSlotId(int32_t slotId)
TELEPHONY_LOGE("permission denied!");
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::SetDefaultVoiceSlotId(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::SetDefaultVoiceSlotId(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -522,7 +522,7 @@ int32_t CoreService::SetDefaultVoiceSlotId(int32_t slotId)
int32_t CoreService::GetDefaultVoiceSlotId()
{
TELEPHONY_LOGI("CoreService::GetDefaultVoiceSlotId()");
TELEPHONY_LOGD("CoreService::GetDefaultVoiceSlotId()");
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERROR;
@ -536,7 +536,7 @@ int32_t CoreService::SetPrimarySlotId(int32_t slotId)
TELEPHONY_LOGE("permission denied!");
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::SetPrimarySlotId(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::SetPrimarySlotId(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -546,7 +546,7 @@ int32_t CoreService::SetPrimarySlotId(int32_t slotId)
int32_t CoreService::GetPrimarySlotId(int32_t &slotId)
{
TELEPHONY_LOGI("CoreService::GetPrimarySlotId()");
TELEPHONY_LOGD("CoreService::GetPrimarySlotId()");
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -560,7 +560,7 @@ int32_t CoreService::SetShowNumber(int32_t slotId, const std::u16string &number)
TELEPHONY_LOGE("permission denied!");
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::SetShowNumber(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::SetShowNumber(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -574,7 +574,7 @@ int32_t CoreService::GetShowNumber(int32_t slotId, std::u16string &showNumber)
TELEPHONY_LOGE("permission denied!");
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::GetShowNumber(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::GetShowNumber(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -588,7 +588,7 @@ int32_t CoreService::SetShowName(int32_t slotId, const std::u16string &name)
TELEPHONY_LOGE("permission denied!");
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::SetShowName(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::SetShowName(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -602,7 +602,7 @@ int32_t CoreService::GetShowName(int32_t slotId, std::u16string &showName)
TELEPHONY_LOGE("permission denied!");
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::GetShowName(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::GetShowName(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -616,7 +616,7 @@ int32_t CoreService::GetActiveSimAccountInfoList(std::vector<IccAccountInfo> &ic
TELEPHONY_LOGE("permission denied!");
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::GetActiveSimAccountInfoList");
TELEPHONY_LOGD("CoreService::GetActiveSimAccountInfoList");
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -630,7 +630,7 @@ int32_t CoreService::GetOperatorConfigs(int32_t slotId, OperatorConfig &poc)
TELEPHONY_LOGE("permission denied!");
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::GetOperatorConfigs");
TELEPHONY_LOGD("CoreService::GetOperatorConfigs");
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -644,7 +644,7 @@ int32_t CoreService::UnlockPin(const int32_t slotId, const std::u16string &pin,
TELEPHONY_LOGE("permission denied!");
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::UnlockPin(), pinLen = %{public}lu, slotId = %{public}d",
TELEPHONY_LOGD("CoreService::UnlockPin(), pinLen = %{public}lu, slotId = %{public}d",
static_cast<unsigned long>(pin.length()), slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
@ -767,7 +767,7 @@ int32_t CoreService::GetLockState(int32_t slotId, LockType lockType, LockState &
int32_t CoreService::RefreshSimState(int32_t slotId)
{
TELEPHONY_LOGI("CoreService::RefreshSimState(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::RefreshSimState(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERROR;
@ -781,7 +781,7 @@ int32_t CoreService::SetActiveSim(int32_t slotId, int32_t enable)
TELEPHONY_LOGE("permission denied!");
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::SetActiveSim(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::SetActiveSim(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -822,7 +822,7 @@ int32_t CoreService::GetSimTelephoneNumber(int32_t slotId, std::u16string &telep
TELEPHONY_LOGE("permission denied!");
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::GetSimTelephoneNumber(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::GetSimTelephoneNumber(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -836,7 +836,7 @@ std::u16string CoreService::GetSimTeleNumberIdentifier(const int32_t slotId)
TELEPHONY_LOGE("CoreService::GetSimTeleNumberIdentifier, Permission denied!");
return std::u16string();
}
TELEPHONY_LOGI("CoreService::GetSimTeleNumberIdentifier(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::GetSimTeleNumberIdentifier(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return std::u16string();
@ -850,7 +850,7 @@ int32_t CoreService::GetVoiceMailIdentifier(int32_t slotId, std::u16string &voic
TELEPHONY_LOGE("permission denied!");
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::GetVoiceMailIdentifier(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::GetVoiceMailIdentifier(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -864,7 +864,7 @@ int32_t CoreService::GetVoiceMailNumber(int32_t slotId, std::u16string &voiceMai
TELEPHONY_LOGE("permission denied!");
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::GetVoiceMailNumber(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::GetVoiceMailNumber(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -879,7 +879,7 @@ int32_t CoreService::QueryIccDiallingNumbers(
TELEPHONY_LOGE("permission denied!");
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::QueryIccDiallingNumbers");
TELEPHONY_LOGD("CoreService::QueryIccDiallingNumbers");
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -894,7 +894,7 @@ int32_t CoreService::AddIccDiallingNumbers(
TELEPHONY_LOGE("permission denied!");
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::AddIccDiallingNumbers");
TELEPHONY_LOGD("CoreService::AddIccDiallingNumbers");
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -909,7 +909,7 @@ int32_t CoreService::DelIccDiallingNumbers(
TELEPHONY_LOGE("permission denied!");
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::DelIccDiallingNumbers");
TELEPHONY_LOGD("CoreService::DelIccDiallingNumbers");
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -924,7 +924,7 @@ int32_t CoreService::UpdateIccDiallingNumbers(
TELEPHONY_LOGE("permission denied!");
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::UpdateIccDiallingNumbers");
TELEPHONY_LOGD("CoreService::UpdateIccDiallingNumbers");
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -939,7 +939,7 @@ int32_t CoreService::SetVoiceMailInfo(
TELEPHONY_LOGE("permission denied!");
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::SetVoiceMailInfo(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::SetVoiceMailInfo(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -957,7 +957,7 @@ int32_t CoreService::GetMaxSimCount()
int32_t CoreService::GetOpKey(int32_t slotId, std::u16string &opkey)
{
TELEPHONY_LOGI("CoreService::GetOpKey(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::GetOpKey(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -967,7 +967,7 @@ int32_t CoreService::GetOpKey(int32_t slotId, std::u16string &opkey)
int32_t CoreService::GetOpKeyExt(int32_t slotId, std::u16string &opkeyExt)
{
TELEPHONY_LOGI("CoreService::GetOpKeyExt(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::GetOpKeyExt(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -977,7 +977,7 @@ int32_t CoreService::GetOpKeyExt(int32_t slotId, std::u16string &opkeyExt)
int32_t CoreService::GetOpName(int32_t slotId, std::u16string &opname)
{
TELEPHONY_LOGI("CoreService::GetOpName(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::GetOpName(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -995,7 +995,7 @@ int32_t CoreService::SendEnvelopeCmd(int32_t slotId, const std::string &cmd)
TELEPHONY_LOGE("CoreService::SendEnvelopeCmd, Permission denied!");
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::SendEnvelopeCmd(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::SendEnvelopeCmd(), slotId = %{public}d", slotId);
return simManager_->SendEnvelopeCmd(slotId, cmd);
}
@ -1009,7 +1009,7 @@ int32_t CoreService::SendTerminalResponseCmd(int32_t slotId, const std::string &
TELEPHONY_LOGE("CoreService::SendTerminalResponseCmd, Permission denied!");
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::SendTerminalResponseCmd(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::SendTerminalResponseCmd(), slotId = %{public}d", slotId);
return simManager_->SendTerminalResponseCmd(slotId, cmd);
}
@ -1023,7 +1023,7 @@ int32_t CoreService::SendCallSetupRequestResult(int32_t slotId, bool accept)
TELEPHONY_LOGE("CoreService::SendCallSetupRequestResult, Permission denied!");
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::SendCallSetupRequestResult(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::SendCallSetupRequestResult(), slotId = %{public}d", slotId);
return simManager_->SendCallSetupRequestResult(slotId, accept);
}
@ -1083,7 +1083,7 @@ int32_t CoreService::SendUpdateCellLocationRequest(int32_t slotId)
int32_t CoreService::HasOperatorPrivileges(const int32_t slotId, bool &hasOperatorPrivileges)
{
TELEPHONY_LOGI("CoreService::HasOperatorPrivileges(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::HasOperatorPrivileges(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;
@ -1098,7 +1098,7 @@ int32_t CoreService::SimAuthentication(
TELEPHONY_LOGE("Failed because no permission:GET_TELEPHONY_STATE");
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::SimAuthentication(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreService::SimAuthentication(), slotId = %{public}d", slotId);
if (simManager_ == nullptr) {
TELEPHONY_LOGE("simManager_ is null");
return TELEPHONY_ERR_LOCAL_PTR_NULL;

22
services/core/src/core_service_stub.cpp
View File

@ -234,7 +234,7 @@ int32_t CoreServiceStub::OnSetRadioState(MessageParcel &data, MessageParcel &rep
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
bool isOn = data.ReadBool();
TELEPHONY_LOGI("CoreServiceStub::OnSetRadioState isOn:%{public}d", isOn);
TELEPHONY_LOGD("CoreServiceStub::OnSetRadioState isOn:%{public}d", isOn);
int32_t result = SetRadioState(slotId, isOn, callback);
if (!reply.WriteInt32(result)) {
TELEPHONY_LOGE("CoreServiceStub::OnSetRadioState write reply failed.");
@ -262,7 +262,7 @@ int32_t CoreServiceStub::OnGetRadioState(MessageParcel &data, MessageParcel &rep
TELEPHONY_LOGE("CoreServiceStub::OnGetRadioState write reply failed.");
return TELEPHONY_ERR_WRITE_DATA_FAIL;
}
TELEPHONY_LOGI("CoreServiceStub::OnGetRadioState result:%{public}d", result);
TELEPHONY_LOGD("CoreServiceStub::OnGetRadioState result:%{public}d", result);
return result;
}
@ -502,7 +502,7 @@ int32_t CoreServiceStub::OnIsSimActive(MessageParcel &data, MessageParcel &reply
{
int32_t slotId = data.ReadInt32();
bool result = IsSimActive(slotId);
TELEPHONY_LOGI("OnRemoteRequest::IsSimActive result is %{public}d", result);
TELEPHONY_LOGD("OnRemoteRequest::IsSimActive result is %{public}d", result);
bool ret = reply.WriteBool(result);
if (!ret) {
TELEPHONY_LOGE("OnRemoteRequest::IsSimActive write reply failed.");
@ -515,7 +515,7 @@ int32_t CoreServiceStub::OnGetSlotId(MessageParcel &data, MessageParcel &reply)
{
int32_t simId = data.ReadInt32();
int32_t result = GetSlotId(simId);
TELEPHONY_LOGI("OnRemoteRequest::OnGetSlotId result is %{public}d", result);
TELEPHONY_LOGD("OnRemoteRequest::OnGetSlotId result is %{public}d", result);
bool ret = reply.WriteInt32(result);
if (!ret) {
TELEPHONY_LOGE("OnRemoteRequest::OnGetSlotId write reply failed.");
@ -528,7 +528,7 @@ int32_t CoreServiceStub::OnGetSimId(MessageParcel &data, MessageParcel &reply)
{
int32_t slotId = data.ReadInt32();
int32_t result = GetSimId(slotId);
TELEPHONY_LOGI("OnRemoteRequest::OnGetSimId result is %{public}d", result);
TELEPHONY_LOGD("OnRemoteRequest::OnGetSimId result is %{public}d", result);
bool ret = reply.WriteInt32(result);
if (!ret) {
TELEPHONY_LOGE("OnRemoteRequest::OnGetSimId write reply failed.");
@ -582,7 +582,7 @@ int32_t CoreServiceStub::OnSetNetworkSelectionMode(MessageParcel &data, MessageP
sptr<INetworkSearchCallback> callback = nullptr;
int32_t slotId = data.ReadInt32();
int32_t selectMode = data.ReadInt32();
TELEPHONY_LOGI("CoreServiceStub::OnSetNetworkSelectionMode selectMode:%{public}d", selectMode);
TELEPHONY_LOGD("CoreServiceStub::OnSetNetworkSelectionMode selectMode:%{public}d", selectMode);
bool resumeSelection = data.ReadBool();
sptr<IRemoteObject> remoteCallback = data.ReadRemoteObject();
if (remoteCallback != nullptr) {
@ -894,7 +894,7 @@ int32_t CoreServiceStub::OnGetLockState(MessageParcel &data, MessageParcel &repl
int32_t CoreServiceStub::OnRefreshSimState(MessageParcel &data, MessageParcel &reply)
{
int32_t slotId = data.ReadInt32();
TELEPHONY_LOGI("CoreServiceStub::OnRefreshSimState(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreServiceStub::OnRefreshSimState(), slotId = %{public}d", slotId);
int32_t result = RefreshSimState(slotId);
bool ret = reply.WriteInt32(result);
if (!ret) {
@ -908,7 +908,7 @@ int32_t CoreServiceStub::OnSetActiveSim(MessageParcel &data, MessageParcel &repl
{
int32_t slotId = data.ReadInt32();
int32_t enable = data.ReadInt32();
TELEPHONY_LOGI("CoreServiceStub::OnSetActiveSim(), slotId = %{public}d", slotId);
TELEPHONY_LOGD("CoreServiceStub::OnSetActiveSim(), slotId = %{public}d", slotId);
int32_t result = SetActiveSim(slotId, enable);
bool ret = reply.WriteInt32(result);
if (!ret) {
@ -924,7 +924,7 @@ int32_t CoreServiceStub::OnGetPreferredNetwork(MessageParcel &data, MessageParce
int32_t slotId = data.ReadInt32();
sptr<IRemoteObject> remoteCallback = data.ReadRemoteObject();
if (remoteCallback != nullptr) {
TELEPHONY_LOGI("CoreServiceStub::OnGetPreferredNetwork remote callback is not null.");
TELEPHONY_LOGD("CoreServiceStub::OnGetPreferredNetwork remote callback is not null.");
callback = iface_cast<INetworkSearchCallback>(remoteCallback);
}
if (callback == nullptr) {
@ -1304,7 +1304,7 @@ int32_t CoreServiceStub::OnSendTerminalResponseCmd(MessageParcel &data, MessageP
int32_t slotId = data.ReadInt32();
std::string cmd = data.ReadString();
int32_t result = SendTerminalResponseCmd(slotId, cmd);
TELEPHONY_LOGI("OnRemoteRequest::OnSendTerminalResponseCmd result is %{public}s", result ? "true" : "false");
TELEPHONY_LOGD("OnRemoteRequest::OnSendTerminalResponseCmd result is %{public}s", result ? "true" : "false");
bool ret = reply.WriteInt32(result);
if (!ret) {
TELEPHONY_LOGE("OnRemoteRequest::OnSendTerminalResponseCmd write reply failed.");
@ -1318,7 +1318,7 @@ int32_t CoreServiceStub::OnSendCallSetupRequestResult(MessageParcel &data, Messa
int32_t slotId = data.ReadInt32();
bool accept = data.ReadInt32();
int32_t result = SendCallSetupRequestResult(slotId, accept);
TELEPHONY_LOGI("OnRemoteRequest::OnSendCallSetupRequestResult result is %{public}d", result);
TELEPHONY_LOGD("OnRemoteRequest::OnSendCallSetupRequestResult result is %{public}d", result);
bool ret = reply.WriteInt32(result);
if (!ret) {
TELEPHONY_LOGE("OnRemoteRequest::OnSendCallSetupRequestResult write reply failed.");

4
services/network_search/src/cell_info.cpp
View File

@ -70,7 +70,7 @@ void CellInfo::InitCellSignalBar(const int32_t bar)
void CellInfo::ProcessNeighboringCellInfo(const AppExecFwk::InnerEvent::Pointer &event)
{
TELEPHONY_LOGI("CellInfo::ProcessNeighboringCellInfo cell info start...... slotId:%{public}d", slotId_);
TELEPHONY_LOGD("CellInfo::ProcessNeighboringCellInfo cell info start...... slotId:%{public}d", slotId_);
std::lock_guard<std::mutex> lock(mutex_);
if (event == nullptr) {
TELEPHONY_LOGE("CellInfo::ProcessNeighboringCellInfo event is nullptr slotId:%{public}d", slotId_);
@ -110,7 +110,7 @@ void CellInfo::ProcessNeighboringCellInfo(const AppExecFwk::InnerEvent::Pointer
void CellInfo::ProcessCurrentCellInfo(const AppExecFwk::InnerEvent::Pointer &event)
{
TELEPHONY_LOGI("CellInfo::ProcessCurrentCellInfo cell info start... slotId:%{public}d", slotId_);
TELEPHONY_LOGD("CellInfo::ProcessCurrentCellInfo cell info start... slotId:%{public}d", slotId_);
std::lock_guard<std::mutex> lock(mutex_);
if (event == nullptr) {
TELEPHONY_LOGE("CellInfo::ProcessCurrentCellInfo event is nullptr slotId:%{public}d", slotId_);

4
services/network_search/src/device_state_handler.cpp
View File

@ -143,7 +143,7 @@ void DeviceStateHandler::SetCellRequestMinInterval(uint32_t minInterval) const
return;
}
if (inner->networkSearchHandler_ != nullptr) {
TELEPHONY_LOGI("DeviceStateHandler::SetCellRequestMinInterval %{public}d", minInterval);
TELEPHONY_LOGD("DeviceStateHandler::SetCellRequestMinInterval %{public}d", minInterval);
inner->networkSearchHandler_->SetCellRequestMinInterval(minInterval);
}
}
@ -177,7 +177,7 @@ void DeviceStateHandler::SetDeviceState(int32_t deviceStateType, bool deviceStat
}
std::shared_ptr<ITelRilManager> telRilManager = telRilManager_.lock();
if (telRilManager != nullptr) {
TELEPHONY_LOGI("DeviceStateHandler::SetDeviceState type:%{public}d state:%{public}d, slotId_:%{public}d",
TELEPHONY_LOGD("DeviceStateHandler::SetDeviceState type:%{public}d state:%{public}d, slotId_:%{public}d",
deviceStateType, deviceStateOn, slotId_);
telRilManager->SetDeviceState(slotId_, deviceStateType, deviceStateOn, event);
}

52
services/network_search/src/network_search_handler.cpp
View File

@ -150,7 +150,7 @@ bool NetworkSearchHandler::InitOperatorName()
void NetworkSearchHandler::RegisterEvents()
{
TELEPHONY_LOGI("NetworkSearchHandler::RegisterEvents start slotId:%{public}d", slotId_);
TELEPHONY_LOGD("NetworkSearchHandler::RegisterEvents start slotId:%{public}d", slotId_);
// Register SIM
{
std::shared_ptr<ISimManager> simManager = simManager_.lock();
@ -219,7 +219,7 @@ void NetworkSearchHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &e
return;
}
auto msgType = event->GetInnerEventId();
TELEPHONY_LOGI(
TELEPHONY_LOGD(
"NetworkSearchHandler::ProcessEvent received event slotId:%{public}d msgType:%{public}d", slotId_, msgType);
auto itFunc = memberFuncMap_.find(static_cast<RadioEvent>(msgType));
if (itFunc != memberFuncMap_.end()) {
@ -320,7 +320,7 @@ void NetworkSearchHandler::RadioRestrictedState(const AppExecFwk::InnerEvent::Po
if (networkRegister_ != nullptr) {
networkRegister_->ProcessRestrictedState(event);
}
TELEPHONY_LOGI("NetworkSearchHandler::RadioRestrictedState slotId:%{public}d", slotId_);
TELEPHONY_LOGD("NetworkSearchHandler::RadioRestrictedState slotId:%{public}d", slotId_);
}
void NetworkSearchHandler::RadioRilDataRegState(const AppExecFwk::InnerEvent::Pointer &event)
@ -338,7 +338,7 @@ void NetworkSearchHandler::RadioRilDataRegState(const AppExecFwk::InnerEvent::Po
if (networkRegister_ != nullptr) {
networkRegister_->ProcessPsRegister(event);
}
TELEPHONY_LOGI("NetworkSearchHandler::RadioRilDataRegState slotId:%{public}d", slotId_);
TELEPHONY_LOGD("NetworkSearchHandler::RadioRilDataRegState slotId:%{public}d", slotId_);
}
void NetworkSearchHandler::RadioRilVoiceRegState(const AppExecFwk::InnerEvent::Pointer &event)
@ -356,7 +356,7 @@ void NetworkSearchHandler::RadioRilVoiceRegState(const AppExecFwk::InnerEvent::P
if (networkRegister_ != nullptr) {
networkRegister_->ProcessCsRegister(event);
}
TELEPHONY_LOGI("NetworkSearchHandler::RadioRilVoiceRegState slotId:%{public}d", slotId_);
TELEPHONY_LOGD("NetworkSearchHandler::RadioRilVoiceRegState slotId:%{public}d", slotId_);
}
void NetworkSearchHandler::RadioSignalStrength(const AppExecFwk::InnerEvent::Pointer &event)
@ -368,7 +368,7 @@ void NetworkSearchHandler::RadioSignalStrength(const AppExecFwk::InnerEvent::Poi
if (signalInfo_ != nullptr) {
signalInfo_->ProcessSignalIntensity(slotId_, event);
}
TELEPHONY_LOGI("NetworkSearchHandler::RadioSignalStrength slotId:%{public}d", slotId_);
TELEPHONY_LOGD("NetworkSearchHandler::RadioSignalStrength slotId:%{public}d", slotId_);
}
void NetworkSearchHandler::RadioRilOperator(const AppExecFwk::InnerEvent::Pointer &event)
@ -380,12 +380,12 @@ void NetworkSearchHandler::RadioRilOperator(const AppExecFwk::InnerEvent::Pointe
if (operatorName_ != nullptr) {
operatorName_->HandleOperatorInfo(event);
}
TELEPHONY_LOGI("NetworkSearchHandler::RadioRilOperator slotId:%{public}d", slotId_);
TELEPHONY_LOGD("NetworkSearchHandler::RadioRilOperator slotId:%{public}d", slotId_);
}
void NetworkSearchHandler::GetRilSignalIntensity(bool checkTime)
{
TELEPHONY_LOGI("NetworkSearchHandler::GetRilSignalIntensity start...... slotId:%{public}d", slotId_);
TELEPHONY_LOGD("NetworkSearchHandler::GetRilSignalIntensity start...... slotId:%{public}d", slotId_);
if (!TimeOutCheck(lastTimeSignalReq_, checkTime)) {
return;
}
@ -431,7 +431,7 @@ void NetworkSearchHandler::GetNetworkStateInfo(const AppExecFwk::InnerEvent::Poi
void NetworkSearchHandler::RadioOffOrUnavailableState(int32_t radioState) const
{
TELEPHONY_LOGI("RadioOffOrUnavailableState enter... slotId:%{public}d", slotId_);
TELEPHONY_LOGD("RadioOffOrUnavailableState enter... slotId:%{public}d", slotId_);
auto networkSearchManager = networkSearchManager_.lock();
if (networkSearchManager == nullptr) {
@ -510,7 +510,7 @@ void NetworkSearchHandler::SetRadioStateResponse(const AppExecFwk::InnerEvent::P
void NetworkSearchHandler::GetRilOperatorInfo(bool checkTime)
{
TELEPHONY_LOGI("NetworkSearchHandler::GetOperatorInfo start slotId:%{public}d", slotId_);
TELEPHONY_LOGD("NetworkSearchHandler::GetOperatorInfo start slotId:%{public}d", slotId_);
if (!TimeOutCheck(lastTimeOperatorReq_, checkTime)) {
return;
}
@ -527,7 +527,7 @@ void NetworkSearchHandler::GetRilOperatorInfo(bool checkTime)
void NetworkSearchHandler::GetRilPsRegistration(bool checkTime)
{
TELEPHONY_LOGI("NetworkSearchHandler::GetPsRegStatus start slotId:%{public}d", slotId_);
TELEPHONY_LOGD("NetworkSearchHandler::GetPsRegStatus start slotId:%{public}d", slotId_);
if (!TimeOutCheck(lastTimePsRegistrationReq_, checkTime)) {
return;
}
@ -554,7 +554,7 @@ void NetworkSearchHandler::InitGetNetworkSelectionMode()
void NetworkSearchHandler::GetRilCsRegistration(bool checkTime)
{
TELEPHONY_LOGI("NetworkSearchHandler::GetCsRegStatus start slotId:%{public}d", slotId_);
TELEPHONY_LOGD("NetworkSearchHandler::GetCsRegStatus start slotId:%{public}d", slotId_);
if (!TimeOutCheck(lastTimeCsRegistrationReq_, checkTime)) {
return;
}
@ -670,7 +670,7 @@ void NetworkSearchHandler::RadioGetImei(const AppExecFwk::InnerEvent::Pointer &e
TELEPHONY_LOGE("NetworkSearchHandler::RadioGetImei event is nullptr!");
return;
}
TELEPHONY_LOGI("NetworkSearchHandler::RadioGetImei start slotId:%{public}d", slotId_);
TELEPHONY_LOGD("NetworkSearchHandler::RadioGetImei start slotId:%{public}d", slotId_);
if (radioInfo_ != nullptr) {
radioInfo_->ProcessGetImei(event);
} else {
@ -680,7 +680,7 @@ void NetworkSearchHandler::RadioGetImei(const AppExecFwk::InnerEvent::Pointer &e
void NetworkSearchHandler::RadioGetMeid(const AppExecFwk::InnerEvent::Pointer &event)
{
TELEPHONY_LOGI("NetworkSearchHandler::RadioGetMeid start slotId:%{public}d", slotId_);
TELEPHONY_LOGD("NetworkSearchHandler::RadioGetMeid start slotId:%{public}d", slotId_);
if (event == nullptr) {
TELEPHONY_LOGE("NetworkSearchHandler::RadioGetMeid event is nullptr!");
return;
@ -736,7 +736,7 @@ void NetworkSearchHandler::RadioGetNeighboringCellInfo(const AppExecFwk::InnerEv
int32_t NetworkSearchHandler::GetCellInfoList(std::vector<sptr<CellInformation>> &cells)
{
TELEPHONY_LOGI("NetworkSearchHandler::GetCellInfoList slotId:%{public}d", slotId_);
TELEPHONY_LOGD("NetworkSearchHandler::GetCellInfoList slotId:%{public}d", slotId_);
if (cellInfo_ != nullptr) {
cellInfo_->GetCellInfoList(cells);
return TELEPHONY_ERR_SUCCESS;
@ -746,7 +746,7 @@ int32_t NetworkSearchHandler::GetCellInfoList(std::vector<sptr<CellInformation>>
sptr<CellLocation> NetworkSearchHandler::GetCellLocation()
{
TELEPHONY_LOGI("NetworkSearchHandler::GetCellLocation slotId:%{public}d", slotId_);
TELEPHONY_LOGD("NetworkSearchHandler::GetCellLocation slotId:%{public}d", slotId_);
if (cellInfo_ != nullptr) {
return cellInfo_->GetCellLocation();
}
@ -755,7 +755,7 @@ sptr<CellLocation> NetworkSearchHandler::GetCellLocation()
void NetworkSearchHandler::TimezoneRefresh()
{
TELEPHONY_LOGI("NetworkSearchHandler::TimezoneRefresh slotId:%{public}d", slotId_);
TELEPHONY_LOGD("NetworkSearchHandler::TimezoneRefresh slotId:%{public}d", slotId_);
if (nitzUpdate_ != nullptr) {
nitzUpdate_->ProcessTimeZone();
}
@ -772,7 +772,7 @@ int32_t NetworkSearchHandler::SendUpdateCellLocationRequest()
TELEPHONY_LOGE("NetworkSearchHandler::SendUpdateCellLocationRequest interval is too short");
return TELEPHONY_ERR_SUCCESS;
}
TELEPHONY_LOGI("NetworkSearchHandler::SendUpdateCellLocationRequest slotId:%{public}d", slotId_);
TELEPHONY_LOGD("NetworkSearchHandler::SendUpdateCellLocationRequest slotId:%{public}d", slotId_);
std::shared_ptr<ITelRilManager> telRilManager = telRilManager_.lock();
auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_CURRENT_CELL_INFO);
if (event != nullptr && telRilManager != nullptr) {
@ -785,7 +785,7 @@ int32_t NetworkSearchHandler::SendUpdateCellLocationRequest()
void NetworkSearchHandler::UpdateCellLocation(int32_t techType, int32_t cellId, int32_t lac)
{
TELEPHONY_LOGI("NetworkSearchHandler::UpdateCellLocation slotId:%{public}d", slotId_);
TELEPHONY_LOGD("NetworkSearchHandler::UpdateCellLocation slotId:%{public}d", slotId_);
if (cellInfo_ != nullptr) {
cellInfo_->UpdateCellLocation(techType, cellId, lac);
}
@ -793,7 +793,7 @@ void NetworkSearchHandler::UpdateCellLocation(int32_t techType, int32_t cellId,
PhoneType NetworkSearchHandler::GetPhoneType()
{
TELEPHONY_LOGI("NetworkSearchHandler::GetPhoneType");
TELEPHONY_LOGD("NetworkSearchHandler::GetPhoneType");
if (radioInfo_ != nullptr) {
return radioInfo_->GetPhoneType();
}
@ -809,7 +809,7 @@ void NetworkSearchHandler::RadioChannelConfigInfo(const AppExecFwk::InnerEvent::
if (networkRegister_ != nullptr) {
networkRegister_->ProcessChannelConfigInfo(event);
}
TELEPHONY_LOGI("NetworkSearchHandler::ProcessChannelConfigInfo slotId:%{public}d", slotId_);
TELEPHONY_LOGD("NetworkSearchHandler::ProcessChannelConfigInfo slotId:%{public}d", slotId_);
}
void NetworkSearchHandler::DcPhysicalLinkActiveUpdate(const AppExecFwk::InnerEvent::Pointer &event)
@ -837,7 +837,7 @@ void NetworkSearchHandler::UpdateImsServiceStatus(const AppExecFwk::InnerEvent::
if (networkSearchState != nullptr) {
networkSearchState->SetImsServiceStatus(*imsServiceStatus);
}
TELEPHONY_LOGI("NetworkSearchHandler::UpdateImsServiceStatus slotId:%{public}d", slotId_);
TELEPHONY_LOGD("NetworkSearchHandler::UpdateImsServiceStatus slotId:%{public}d", slotId_);
}
void NetworkSearchHandler::UpdateImsRegisterState(const AppExecFwk::InnerEvent::Pointer &event)
@ -866,12 +866,12 @@ void NetworkSearchHandler::RadioVoiceTechChange(const AppExecFwk::InnerEvent::Po
if (radioInfo_ != nullptr) {
radioInfo_->ProcessVoiceTechChange(event);
}
TELEPHONY_LOGI("NetworkSearchHandler::RadioVoiceTechChange");
TELEPHONY_LOGD("NetworkSearchHandler::RadioVoiceTechChange");
}
void NetworkSearchHandler::AutoTimeChange(const AppExecFwk::InnerEvent::Pointer &)
{
TELEPHONY_LOGI("NetworkSearchHandler::AutoTimeChange");
TELEPHONY_LOGD("NetworkSearchHandler::AutoTimeChange");
if (nitzUpdate_ != nullptr) {
nitzUpdate_->AutoTimeChange();
}
@ -879,7 +879,7 @@ void NetworkSearchHandler::AutoTimeChange(const AppExecFwk::InnerEvent::Pointer
void NetworkSearchHandler::AutoTimeZoneChange(const AppExecFwk::InnerEvent::Pointer &)
{
TELEPHONY_LOGI("NetworkSearchHandler::AutoTimeZoneChange");
TELEPHONY_LOGD("NetworkSearchHandler::AutoTimeZoneChange");
if (nitzUpdate_ != nullptr) {
nitzUpdate_->AutoTimeZoneChange();
}
@ -887,7 +887,7 @@ void NetworkSearchHandler::AutoTimeZoneChange(const AppExecFwk::InnerEvent::Poin
void NetworkSearchHandler::AirplaneModeChange(const AppExecFwk::InnerEvent::Pointer &)
{
TELEPHONY_LOGI("NetworkSearchHandler::AirplaneModeChange");
TELEPHONY_LOGD("NetworkSearchHandler::AirplaneModeChange");
if (radioInfo_ != nullptr) {
radioInfo_->AirplaneModeChange();
}

84
services/network_search/src/network_search_manager.cpp
View File

@ -202,7 +202,7 @@ std::shared_ptr<NetworkSearchState> NetworkSearchManager::GetNetworkSearchState(
{
auto inner = FindManagerInner(slotId);
if (inner != nullptr) {
TELEPHONY_LOGI("NetworkSearchManager::GetNetworkSearchState slotId:%{public}d", slotId);
TELEPHONY_LOGD("NetworkSearchManager::GetNetworkSearchState slotId:%{public}d", slotId);
return inner->networkSearchState_;
}
return nullptr;
@ -210,7 +210,7 @@ std::shared_ptr<NetworkSearchState> NetworkSearchManager::GetNetworkSearchState(
void NetworkSearchManager::SetRadioState(int32_t slotId, bool isOn, int32_t rst)
{
TELEPHONY_LOGI("NetworkSearchManager SetRadioState isOn:%{public}d slotId:%{public}d", isOn, slotId);
TELEPHONY_LOGD("NetworkSearchManager SetRadioState isOn:%{public}d slotId:%{public}d", isOn, slotId);
auto inner = FindManagerInner(slotId);
if (inner == nullptr) {
TELEPHONY_LOGE("slotId:%{public}d inner is null", slotId);
@ -222,7 +222,7 @@ void NetworkSearchManager::SetRadioState(int32_t slotId, bool isOn, int32_t rst)
int32_t NetworkSearchManager::SetRadioState(int32_t slotId, bool isOn, int32_t rst, NSCALLBACK &callback)
{
TELEPHONY_LOGI("NetworkSearchManager SetRadioState isOn:%{public}d slotId:%{public}d", isOn, slotId);
TELEPHONY_LOGD("NetworkSearchManager SetRadioState isOn:%{public}d slotId:%{public}d", isOn, slotId);
auto inner = FindManagerInner(slotId);
if (inner == nullptr) {
TELEPHONY_LOGE("slotId:%{public}d inner is null", slotId);
@ -239,7 +239,7 @@ int32_t NetworkSearchManager::SetRadioState(int32_t slotId, bool isOn, int32_t r
void NetworkSearchManager::RegisterCoreNotify(int32_t slotId, HANDLE &handler, int32_t what)
{
TELEPHONY_LOGI("NetworkSearchManager::RegisterCoreNotify %{public}d slotId:%{public}d", what, slotId);
TELEPHONY_LOGD("NetworkSearchManager::RegisterCoreNotify %{public}d slotId:%{public}d", what, slotId);
auto inner = FindManagerInner(slotId);
if (inner != nullptr) {
if (inner->observerHandler_ != nullptr) {
@ -250,7 +250,7 @@ void NetworkSearchManager::RegisterCoreNotify(int32_t slotId, HANDLE &handler, i
void NetworkSearchManager::UnRegisterCoreNotify(int32_t slotId, HANDLE &handler, int32_t what)
{
TELEPHONY_LOGI("NetworkSearchManager::UnRegisterCoreNotify %{public}d slotId:%{public}d", what, slotId);
TELEPHONY_LOGD("NetworkSearchManager::UnRegisterCoreNotify %{public}d slotId:%{public}d", what, slotId);
auto inner = FindManagerInner(slotId);
if (inner != nullptr) {
if (inner->observerHandler_ != nullptr) {
@ -281,7 +281,7 @@ void NetworkSearchManager::UnRegisterCellularCallObject(const sptr<NetworkSearch
void NetworkSearchManager::NotifyPsRoamingOpenChanged(int32_t slotId)
{
TELEPHONY_LOGI("NetworkSearchManager::NotifyPsRoamingOpenChanged slotId:%{public}d", slotId);
TELEPHONY_LOGD("NetworkSearchManager::NotifyPsRoamingOpenChanged slotId:%{public}d", slotId);
auto inner = FindManagerInner(slotId);
if (inner != nullptr) {
if (inner->observerHandler_ != nullptr) {
@ -292,7 +292,7 @@ void NetworkSearchManager::NotifyPsRoamingOpenChanged(int32_t slotId)
void NetworkSearchManager::NotifyPsRoamingCloseChanged(int32_t slotId)
{
TELEPHONY_LOGI("NetworkSearchManager::NotifyPsRoamingCloseChanged slotId:%{public}d", slotId);
TELEPHONY_LOGD("NetworkSearchManager::NotifyPsRoamingCloseChanged slotId:%{public}d", slotId);
auto inner = FindManagerInner(slotId);
if (inner != nullptr) {
if (inner->observerHandler_ != nullptr) {
@ -303,7 +303,7 @@ void NetworkSearchManager::NotifyPsRoamingCloseChanged(int32_t slotId)
void NetworkSearchManager::NotifyEmergencyOpenChanged(int32_t slotId)
{
TELEPHONY_LOGI("NetworkSearchManager::NotifyEmergencyOpenChanged slotId:%{public}d", slotId);
TELEPHONY_LOGD("NetworkSearchManager::NotifyEmergencyOpenChanged slotId:%{public}d", slotId);
auto inner = FindManagerInner(slotId);
if (inner != nullptr) {
if (inner->observerHandler_ != nullptr) {
@ -314,7 +314,7 @@ void NetworkSearchManager::NotifyEmergencyOpenChanged(int32_t slotId)
void NetworkSearchManager::NotifyEmergencyCloseChanged(int32_t slotId)
{
TELEPHONY_LOGI("NetworkSearchManager::NotifyEmergencyCloseChanged slotId:%{public}d", slotId);
TELEPHONY_LOGD("NetworkSearchManager::NotifyEmergencyCloseChanged slotId:%{public}d", slotId);
auto inner = FindManagerInner(slotId);
if (inner != nullptr) {
if (inner->observerHandler_ != nullptr) {
@ -325,7 +325,7 @@ void NetworkSearchManager::NotifyEmergencyCloseChanged(int32_t slotId)
void NetworkSearchManager::NotifyPsRatChanged(int32_t slotId)
{
TELEPHONY_LOGI("NetworkSearchManager::NotifyPsRatChanged slotId:%{public}d", slotId);
TELEPHONY_LOGD("NetworkSearchManager::NotifyPsRatChanged slotId:%{public}d", slotId);
auto inner = FindManagerInner(slotId);
if (inner != nullptr) {
if (inner->observerHandler_ != nullptr) {
@ -336,7 +336,7 @@ void NetworkSearchManager::NotifyPsRatChanged(int32_t slotId)
void NetworkSearchManager::NotifyPsConnectionAttachedChanged(int32_t slotId)
{
TELEPHONY_LOGI("NetworkSearchManager::NotifyPsConnectionAttachedChanged slotId:%{public}d", slotId);
TELEPHONY_LOGD("NetworkSearchManager::NotifyPsConnectionAttachedChanged slotId:%{public}d", slotId);
auto inner = FindManagerInner(slotId);
if (inner != nullptr) {
if (inner->observerHandler_ != nullptr) {
@ -347,7 +347,7 @@ void NetworkSearchManager::NotifyPsConnectionAttachedChanged(int32_t slotId)
void NetworkSearchManager::NotifyPsConnectionDetachedChanged(int32_t slotId)
{
TELEPHONY_LOGI("NetworkSearchManager::NotifyPsConnectionDetachedChanged slotId:%{public}d", slotId);
TELEPHONY_LOGD("NetworkSearchManager::NotifyPsConnectionDetachedChanged slotId:%{public}d", slotId);
auto inner = FindManagerInner(slotId);
if (inner != nullptr) {
if (inner->observerHandler_ != nullptr) {
@ -358,7 +358,7 @@ void NetworkSearchManager::NotifyPsConnectionDetachedChanged(int32_t slotId)
void NetworkSearchManager::NotifyNrStateChanged(int32_t slotId)
{
TELEPHONY_LOGI("NetworkSearchManager::NotifyNrStateChanged slotId:%{public}d", slotId);
TELEPHONY_LOGD("NetworkSearchManager::NotifyNrStateChanged slotId:%{public}d", slotId);
auto inner = FindManagerInner(slotId);
if (inner != nullptr) {
if (inner->observerHandler_ != nullptr) {
@ -369,7 +369,7 @@ void NetworkSearchManager::NotifyNrStateChanged(int32_t slotId)
void NetworkSearchManager::NotifyNrFrequencyChanged(int32_t slotId)
{
TELEPHONY_LOGI("NetworkSearchManager::NotifyNrFrequencyChanged slotId:%{public}d", slotId);
TELEPHONY_LOGD("NetworkSearchManager::NotifyNrFrequencyChanged slotId:%{public}d", slotId);
auto inner = FindManagerInner(slotId);
if (inner != nullptr) {
if (inner->observerHandler_ != nullptr) {
@ -390,7 +390,7 @@ int32_t NetworkSearchManager::GetPsRadioTech(int32_t slotId, int32_t &psRadioTec
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
psRadioTech = static_cast<int32_t>(inner->networkSearchState_->GetNetworkStatus()->GetPsRadioTech());
TELEPHONY_LOGI("NetworkSearchManager::GetPsRadioTech result=%{public}d slotId:%{public}d", psRadioTech, slotId);
TELEPHONY_LOGD("NetworkSearchManager::GetPsRadioTech result=%{public}d slotId:%{public}d", psRadioTech, slotId);
return TELEPHONY_ERR_SUCCESS;
}
@ -406,7 +406,7 @@ int32_t NetworkSearchManager::GetCsRadioTech(int32_t slotId, int32_t &csRadioTec
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
csRadioTech = static_cast<int32_t>(inner->networkSearchState_->GetNetworkStatus()->GetCsRadioTech());
TELEPHONY_LOGI("NetworkSearchManager::GetCsRadioTech result=%{public}d slotId:%{public}d", csRadioTech, slotId);
TELEPHONY_LOGD("NetworkSearchManager::GetCsRadioTech result=%{public}d slotId:%{public}d", csRadioTech, slotId);
return TELEPHONY_ERR_SUCCESS;
}
@ -416,7 +416,7 @@ int32_t NetworkSearchManager::GetPsRegState(int32_t slotId)
if (inner != nullptr) {
if (inner->networkSearchState_ != nullptr && inner->networkSearchState_->GetNetworkStatus() != nullptr) {
auto event = static_cast<int32_t>(inner->networkSearchState_->GetNetworkStatus()->GetPsRegStatus());
TELEPHONY_LOGI("NetworkSearchManager::GetPsRegState result=%{public}d slotId:%{public}d", event, slotId);
TELEPHONY_LOGD("NetworkSearchManager::GetPsRegState result=%{public}d slotId:%{public}d", event, slotId);
return event;
}
TELEPHONY_LOGE("NetworkSearchManager::GetPsRegState failed due to nullptr!");
@ -431,7 +431,7 @@ int32_t NetworkSearchManager::GetCsRegState(int32_t slotId)
if (inner != nullptr) {
if (inner->networkSearchState_ != nullptr && inner->networkSearchState_->GetNetworkStatus() != nullptr) {
auto event = static_cast<int32_t>(inner->networkSearchState_->GetNetworkStatus()->GetCsRegStatus());
TELEPHONY_LOGI("NetworkSearchManager::GetCsRegState result=%{public}d slotId:%{public}d", event, slotId);
TELEPHONY_LOGD("NetworkSearchManager::GetCsRegState result=%{public}d slotId:%{public}d", event, slotId);
return event;
}
TELEPHONY_LOGE("NetworkSearchManager::GetCsRegState failed due to nullptr!");
@ -446,7 +446,7 @@ int32_t NetworkSearchManager::GetPsRoamingState(int32_t slotId)
if (inner != nullptr) {
if (inner->networkSearchState_ != nullptr && inner->networkSearchState_->GetNetworkStatus() != nullptr) {
auto event = static_cast<int32_t>(inner->networkSearchState_->GetNetworkStatus()->GetPsRoamingStatus());
TELEPHONY_LOGI(
TELEPHONY_LOGD(
"NetworkSearchManager::GetPsRoamingState result=%{public}d slotId:%{public}d", event, slotId);
return event;
}
@ -458,14 +458,14 @@ int32_t NetworkSearchManager::GetPsRoamingState(int32_t slotId)
std::u16string NetworkSearchManager::GetOperatorNumeric(int32_t slotId)
{
TELEPHONY_LOGI("NetworkSearchManager::GetOperatorNumeric start slotId:%{public}d", slotId);
TELEPHONY_LOGD("NetworkSearchManager::GetOperatorNumeric start slotId:%{public}d", slotId);
std::u16string str;
auto inner = FindManagerInner(slotId);
if (inner != nullptr) {
if (inner->networkSearchState_ != nullptr && inner->networkSearchState_->GetNetworkStatus() != nullptr) {
auto event = inner->networkSearchState_->GetNetworkStatus()->GetPlmnNumeric();
str = Str8ToStr16(event);
TELEPHONY_LOGI(
TELEPHONY_LOGD(
"NetworkSearchManager::GetOperatorNumeric result=%{public}s slotId:%{public}d", event.c_str(), slotId);
}
}
@ -480,7 +480,7 @@ int32_t NetworkSearchManager::GetOperatorName(int32_t slotId, std::u16string &op
if (inner->networkSearchState_ != nullptr && inner->networkSearchState_->GetNetworkStatus() != nullptr) {
auto longOperatorName = inner->networkSearchState_->GetNetworkStatus()->GetLongOperatorName();
operatorName = Str8ToStr16(longOperatorName);
TELEPHONY_LOGI("NetworkSearchManager::GetOperatorName result:%{public}s slotId:%{public}d",
TELEPHONY_LOGD("NetworkSearchManager::GetOperatorName result:%{public}s slotId:%{public}d",
longOperatorName.c_str(), slotId);
return TELEPHONY_ERR_SUCCESS;
}
@ -527,7 +527,7 @@ int32_t NetworkSearchManager::GetRadioState(int32_t slotId)
int32_t NetworkSearchManager::GetRadioState(int32_t slotId, NSCALLBACK &callback)
{
TELEPHONY_LOGI("NetworkSearchManager::GetRadioState... slotId:%{public}d", slotId);
TELEPHONY_LOGD("NetworkSearchManager::GetRadioState... slotId:%{public}d", slotId);
auto inner = FindManagerInner(slotId);
if (inner == nullptr) {
TELEPHONY_LOGE("slotId:%{public}d inner is null", slotId);
@ -629,7 +629,7 @@ int32_t NetworkSearchManager::GetNetworkSelectionMode(int32_t slotId, NSCALLBACK
bool NetworkSearchManager::SetNetworkSelectionMode(
int32_t slotId, int32_t selectMode, const sptr<NetworkInformation> &networkInformation, bool resumeSelection)
{
TELEPHONY_LOGI(
TELEPHONY_LOGD(
"NetworkSearchManager SetNetworkSelectionMode selectMode:%{public}d slotId:%{public}d", selectMode, slotId);
auto inner = FindManagerInner(slotId);
if (inner == nullptr) {
@ -646,7 +646,7 @@ bool NetworkSearchManager::SetNetworkSelectionMode(
int32_t NetworkSearchManager::SetNetworkSelectionMode(int32_t slotId, int32_t selectMode,
const sptr<NetworkInformation> &networkInformation, bool resumeSelection, NSCALLBACK &callback)
{
TELEPHONY_LOGI(
TELEPHONY_LOGD(
"NetworkSearchManager SetNetworkSelectionMode selectMode:%{public}d slotId:%{public}d", selectMode, slotId);
auto inner = FindManagerInner(slotId);
if (inner == nullptr) {
@ -692,7 +692,7 @@ int32_t NetworkSearchManager::GetIsoCountryCodeForNetwork(int32_t slotId, std::u
} else {
TELEPHONY_LOGE("GetIsoCountryCodeForNetwork parse Failed!! slotId:%{public}d", slotId);
}
TELEPHONY_LOGI(
TELEPHONY_LOGD(
"NetworkSearchManager::GetIsoCountryCodeForNetwork mcc=%{public}s code=%{public}d slotId:%{public}d",
mcc.c_str(), value, slotId);
}
@ -738,7 +738,7 @@ int32_t NetworkSearchManager::SetPreferredNetwork(int32_t slotId, int32_t networ
return TELEPHONY_ERR_ARGUMENT_INVALID;
}
int32_t filterMode = static_cast<int32_t>(NetworkUtils::GetNetworkModeFromRaf(modemRaf & raf));
TELEPHONY_LOGI("SetPreferredNetwork filterMode:%{public}d slotId:%{public}d", filterMode, slotId);
TELEPHONY_LOGD("SetPreferredNetwork filterMode:%{public}d slotId:%{public}d", filterMode, slotId);
if (!eventSender_->SendCallbackEx(slotId, RadioEvent::RADIO_SET_PREFERRED_NETWORK_MODE, &callback, filterMode)) {
TELEPHONY_LOGE("slotId:%{public}d SetPreferredNetwork SendCallback failed.", slotId);
return CORE_SERVICE_SEND_CALLBACK_FAILED;
@ -748,7 +748,7 @@ int32_t NetworkSearchManager::SetPreferredNetwork(int32_t slotId, int32_t networ
bool NetworkSearchManager::GetPreferredNetwork(int32_t slotId)
{
TELEPHONY_LOGI("NetworkSearchManager GetPreferredNetwork slotId:%{public}d", slotId);
TELEPHONY_LOGD("NetworkSearchManager GetPreferredNetwork slotId:%{public}d", slotId);
auto inner = FindManagerInner(slotId);
if (inner == nullptr) {
TELEPHONY_LOGE("slotId:%{public}d inner is null", slotId);
@ -782,17 +782,17 @@ bool NetworkSearchManager::SetPreferredNetwork(int32_t slotId, int32_t networkMo
return false;
}
int32_t filterMode = static_cast<int32_t>(NetworkUtils::GetNetworkModeFromRaf(modemRaf & raf));
TELEPHONY_LOGI("SetPreferredNetwork filterMode:%{public}d slotId:%{public}d", filterMode, slotId);
TELEPHONY_LOGD("SetPreferredNetwork filterMode:%{public}d slotId:%{public}d", filterMode, slotId);
return eventSender_->SendBase(slotId, RadioEvent::RADIO_SET_PREFERRED_NETWORK_MODE, filterMode);
}
void NetworkSearchManager::SavePreferredNetworkValue(int32_t slotId, int32_t networkMode)
{
TELEPHONY_LOGI("NetworkSearchManager SavePreferredNetworkValue slotId:%{public}d, networkMode:%{public}d", slotId,
TELEPHONY_LOGD("NetworkSearchManager SavePreferredNetworkValue slotId:%{public}d, networkMode:%{public}d", slotId,
networkMode);
std::shared_ptr<SettingUtils> settingHelper = SettingUtils::GetInstance();
if (settingHelper == nullptr) {
TELEPHONY_LOGI("settingHelper is null");
TELEPHONY_LOGE("settingHelper is null");
return;
}
@ -809,7 +809,7 @@ int32_t NetworkSearchManager::GetPreferredNetworkValue(int32_t slotId) const
int32_t networkMode = PREFERRED_NETWORK_TYPE;
std::shared_ptr<SettingUtils> settingHelper = SettingUtils::GetInstance();
if (settingHelper == nullptr) {
TELEPHONY_LOGI("settingHelper is null");
TELEPHONY_LOGE("settingHelper is null");
return networkMode;
}
@ -822,7 +822,7 @@ int32_t NetworkSearchManager::GetPreferredNetworkValue(int32_t slotId) const
}
bool succ = StrToInt(value, networkMode);
TELEPHONY_LOGI("NetworkSearchManager GetPreferredNetworkValue succ:%{public}d, slotId:%{public}d, "
TELEPHONY_LOGD("NetworkSearchManager GetPreferredNetworkValue succ:%{public}d, slotId:%{public}d, "
"networkMode:%{public}d",
slotId, succ, networkMode);
return networkMode;
@ -840,7 +840,7 @@ void NetworkSearchManager::UpdatePhone(int32_t slotId, RadioTech csRadioTech, co
int32_t NetworkSearchManager::GetImsRegStatus(int32_t slotId, ImsServiceType imsSrvType, ImsRegInfo &info)
{
TELEPHONY_LOGI("slotId:%{public}d, imsSrvType:%{public}d", slotId, imsSrvType);
TELEPHONY_LOGD("slotId:%{public}d, imsSrvType:%{public}d", slotId, imsSrvType);
auto inner = FindManagerInner(slotId);
if (inner == nullptr) {
TELEPHONY_LOGE("NetworkSearchManagerInner is nullptr!");
@ -863,7 +863,7 @@ void NetworkSearchManager::SetImei(int32_t slotId, std::u16string imei)
int32_t NetworkSearchManager::GetImei(int32_t slotId, std::u16string &imei)
{
TELEPHONY_LOGI("NetworkSearchManager::GetImei start slotId:%{public}d", slotId);
TELEPHONY_LOGD("NetworkSearchManager::GetImei start slotId:%{public}d", slotId);
imei = u"";
auto inner = FindManagerInner(slotId);
if (inner == nullptr) {
@ -933,7 +933,7 @@ void NetworkSearchManager::SetMeid(int32_t slotId, std::u16string meid)
int32_t NetworkSearchManager::GetMeid(int32_t slotId, std::u16string &meid)
{
TELEPHONY_LOGI("NetworkSearchManager::GetMeid start slotId:%{public}d", slotId);
TELEPHONY_LOGD("NetworkSearchManager::GetMeid start slotId:%{public}d", slotId);
meid = u"";
auto inner = FindManagerInner(slotId);
if (inner == nullptr) {
@ -950,7 +950,7 @@ int32_t NetworkSearchManager::GetMeid(int32_t slotId, std::u16string &meid)
void NetworkSearchManager::SetLocateUpdate(int32_t slotId)
{
TELEPHONY_LOGI("NetworkSearchManager::SetLocateUpdate start slotId:%{public}d", slotId);
TELEPHONY_LOGD("NetworkSearchManager::SetLocateUpdate start slotId:%{public}d", slotId);
auto inner = FindManagerInner(slotId);
if (inner == nullptr) {
TELEPHONY_LOGI("NetworkSearchManager::SetLocateUpdate inner null slotId:%{public}d", slotId);
@ -966,7 +966,7 @@ void NetworkSearchManager::SetLocateUpdate(int32_t slotId)
int32_t NetworkSearchManager::GetUniqueDeviceId(int32_t slotId, std::u16string &deviceId)
{
TELEPHONY_LOGI("NetworkSearchManager::GetUniqueDeviceId start slotId:%{public}d", slotId);
TELEPHONY_LOGD("NetworkSearchManager::GetUniqueDeviceId start slotId:%{public}d", slotId);
deviceId = u"";
auto inner = FindManagerInner(slotId);
if (inner == nullptr) {
@ -1153,7 +1153,7 @@ bool NetworkSearchManager::RemoveManagerInner(int32_t slotId)
void NetworkSearchManager::TriggerSimRefresh(int32_t slotId)
{
TELEPHONY_LOGI("NetworkSearchManager::TriggerSimRefresh %{public}d", slotId);
TELEPHONY_LOGD("NetworkSearchManager::TriggerSimRefresh %{public}d", slotId);
auto inner = FindManagerInner(slotId);
if (inner != nullptr && simManager_ != nullptr) {
if (inner->networkSearchHandler_ != nullptr) {
@ -1223,7 +1223,7 @@ int32_t NetworkSearchManager::RegisterImsRegInfoCallback(
imsRecord.bundleName = bundleName;
imsRecord.imsCallback = callback;
listImsRegInfoCallbackRecord_.push_back(imsRecord);
TELEPHONY_LOGI("[slot%{public}d] Register successfully, callback list size is %{public}zu", slotId,
TELEPHONY_LOGD("[slot%{public}d] Register successfully, callback list size is %{public}zu", slotId,
listImsRegInfoCallbackRecord_.size());
return TELEPHONY_SUCCESS;
}
@ -1245,14 +1245,14 @@ int32_t NetworkSearchManager::UnregisterImsRegInfoCallback(
TELEPHONY_LOGI("[slot%{public}d] Ignore unregister action, since callback is nonexistent", slotId);
return TELEPHONY_SUCCESS;
}
TELEPHONY_LOGI("[slot%{public}d] Unregister successfully, callback list size is %{public}zu", slotId,
TELEPHONY_LOGD("[slot%{public}d] Unregister successfully, callback list size is %{public}zu", slotId,
listImsRegInfoCallbackRecord_.size());
return TELEPHONY_SUCCESS;
}
void NetworkSearchManager::NotifyImsRegInfoChanged(int32_t slotId, ImsServiceType imsSrvType, const ImsRegInfo &info)
{
TELEPHONY_LOGI(
TELEPHONY_LOGD(
"slotId:%{public}d, ImsRegState:%{public}d, ImsRegTech:%{public}d", slotId, info.imsRegState, info.imsRegTech);
bool isExisted = false;
std::lock_guard<std::mutex> lock(mutexInner_);

10
services/network_search/src/network_search_notify.cpp
View File

@ -34,7 +34,7 @@ void NetworkSearchNotify::NotifyNetworkStateUpdated(int32_t slotId, const sptr<N
}
int32_t result =
DelayedRefSingleton<TelephonyStateRegistryClient>::GetInstance().UpdateNetworkState(slotId, networkState);
TELEPHONY_LOGI("NotifyNetworkStateUpdated ret %{public}s", networkState->ToString().c_str());
TELEPHONY_LOGD("NotifyNetworkStateUpdated ret %{public}s", networkState->ToString().c_str());
if (result != TELEPHONY_SUCCESS) {
TELEPHONY_LOGE("NotifyNetworkStateUpdated TELEPHONY_STATE_REGISTRY_SYS_ABILITY_ID not found");
}
@ -43,10 +43,10 @@ void NetworkSearchNotify::NotifyNetworkStateUpdated(int32_t slotId, const sptr<N
void NetworkSearchNotify::NotifySignalInfoUpdated(
int32_t slotId, const std::vector<sptr<SignalInformation>> &signalInfos)
{
TELEPHONY_LOGI("NotifySignalInfoUpdated~~~ signalInfos size=%{public}zu", signalInfos.size());
TELEPHONY_LOGD("NotifySignalInfoUpdated~~~ signalInfos size=%{public}zu", signalInfos.size());
int32_t result =
DelayedRefSingleton<TelephonyStateRegistryClient>::GetInstance().UpdateSignalInfo(slotId, signalInfos);
TELEPHONY_LOGI("NotifySignalInfoUpdated ret %{public}d", result);
TELEPHONY_LOGD("NotifySignalInfoUpdated ret %{public}d", result);
if (result != TELEPHONY_SUCCESS) {
TELEPHONY_LOGE("NotifySignalInfoUpdated TELEPHONY_STATE_REGISTRY_SYS_ABILITY_ID not found");
}
@ -54,10 +54,10 @@ void NetworkSearchNotify::NotifySignalInfoUpdated(
void NetworkSearchNotify::NotifyCellInfoUpdated(int32_t slotId, const std::vector<sptr<CellInformation>> &cellInfos)
{
TELEPHONY_LOGI("NotifyCellInfoUpdated~~~ cell size=%{public}zu", cellInfos.size());
TELEPHONY_LOGD("NotifyCellInfoUpdated~~~ cell size=%{public}zu", cellInfos.size());
int32_t result =
DelayedRefSingleton<TelephonyStateRegistryClient>::GetInstance().UpdateCellInfo(slotId, cellInfos);
TELEPHONY_LOGI("NotifyCellInfoUpdated ret %{public}d", result);
TELEPHONY_LOGD("NotifyCellInfoUpdated ret %{public}d", result);
if (result != TELEPHONY_SUCCESS) {
TELEPHONY_LOGE("NotifyCellInfoUpdated TELEPHONY_STATE_REGISTRY_SYS_ABILITY_ID not found.");
}

13
services/network_search/src/operator_name.cpp
View File

@ -362,7 +362,7 @@ std::string OperatorName::GetPlmn(const sptr<NetworkState> &networkState, bool l
if (plmn.empty()) {
plmn = networkState->GetLongOperatorName();
}
TELEPHONY_LOGI(
TELEPHONY_LOGD(
"OperatorName::GetPlmn lac:%{public}d, numeric:%{public}s, longNameRequired:%{public}d, plmn:%{public}s", lac,
numeric.c_str(), longNameRequired, plmn.c_str());
return plmn;
@ -412,8 +412,7 @@ std::string OperatorName::GetCustEons(const std::string &numeric, int32_t lac, b
pnnIndex = -1;
TELEPHONY_LOGI(
"OperatorName::GetCustEons numeric:%{public}s, opl->plmnNumeric:%{public}s, lac:%{public}d, "
"opl->lacStart:%{public}d, opl->lacEnd:%{public}d, "
"opl->pnnRecordId:%{public}d",
"opl->lacStart:%{public}d, opl->lacEnd:%{public}d, opl->pnnRecordId:%{public}d",
numeric.c_str(), opl->plmnNumeric.c_str(), lac, opl->lacStart, opl->lacEnd, opl->pnnRecordId);
if (numeric.compare(opl->plmnNumeric) == 0 &&
((opl->lacStart == 0 && opl->lacEnd == 0xfffe) || (opl->lacStart <= lac && opl->lacEnd >= lac))) {
@ -439,7 +438,7 @@ std::string OperatorName::GetCustEons(const std::string &numeric, int32_t lac, b
std::string OperatorName::GetCustomName(const std::string &numeric)
{
TELEPHONY_LOGI("OperatorName::GetCustomName numeric:%{public}s", numeric.c_str());
TELEPHONY_LOGD("OperatorName::GetCustomName numeric:%{public}s", numeric.c_str());
std::string name = "";
if (numeric.empty()) {
return name;
@ -447,19 +446,19 @@ std::string OperatorName::GetCustomName(const std::string &numeric)
auto obj = std::find(cmMccMnc_.begin(), cmMccMnc_.end(), numeric);
if (obj != cmMccMnc_.end()) {
ResourceUtils::Get().GetValueByName<std::string>(ResourceUtils::CMCC, name);
TELEPHONY_LOGI("OperatorName::GetCustomName CMCC:%{public}s", name.c_str());
TELEPHONY_LOGD("OperatorName::GetCustomName CMCC:%{public}s", name.c_str());
return name;
}
obj = std::find(cuMccMnc_.begin(), cuMccMnc_.end(), numeric);
if (obj != cuMccMnc_.end()) {
ResourceUtils::Get().GetValueByName<std::string>(ResourceUtils::CUCC, name);
TELEPHONY_LOGI("OperatorName::GetCustomName CUCC:%{public}s", name.c_str());
TELEPHONY_LOGD("OperatorName::GetCustomName CUCC:%{public}s", name.c_str());
return name;
}
obj = std::find(ctMccMnc_.begin(), ctMccMnc_.end(), numeric);
if (obj != ctMccMnc_.end()) {
ResourceUtils::Get().GetValueByName<std::string>(ResourceUtils::CTCC, name);
TELEPHONY_LOGI("OperatorName::GetCustomName CTCC:%{public}s", name.c_str());
TELEPHONY_LOGD("OperatorName::GetCustomName CTCC:%{public}s", name.c_str());
return name;
}
return name;

22
services/sim/src/icc_file_controller.cpp
View File

@ -31,7 +31,7 @@ void IccFileController::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &even
return;
}
uint32_t id = event->GetInnerEventId();
TELEPHONY_LOGI("IccFileController ProcessEvent Id is %{public}d", id);
TELEPHONY_LOGD("IccFileController ProcessEvent Id is %{public}d", id);
if (ProcessErrorResponse(event)) {
return;
}
@ -238,7 +238,7 @@ std::string IccFileController::ObtainElementFileForPublic(int efId)
// implementation ObtainBinaryFile
void IccFileController::ObtainBinaryFile(int fileId, const AppExecFwk::InnerEvent::Pointer &event)
{
TELEPHONY_LOGI("IccFileController::ObtainBinaryFile start");
TELEPHONY_LOGD("IccFileController::ObtainBinaryFile start");
AppExecFwk::InnerEvent::Pointer process =
BuildCallerInfo(MSG_SIM_OBTAIN_SIZE_OF_TRANSPARENT_ELEMENTARY_FILE_DONE, fileId, 0, event);
if (telRilManager_ != nullptr) {
@ -253,7 +253,7 @@ void IccFileController::ObtainBinaryFile(int fileId, const AppExecFwk::InnerEven
msg.pin2 = "";
telRilManager_->GetSimIO(slotId_, msg, process);
}
TELEPHONY_LOGI("IccFileController::ObtainBinaryFile end");
TELEPHONY_LOGD("IccFileController::ObtainBinaryFile end");
}
void IccFileController::ObtainBinaryFile(int fileId, int size, const AppExecFwk::InnerEvent::Pointer &event)
@ -433,7 +433,7 @@ void IccFileController::SendResponse(std::shared_ptr<IccControllerHolder> holder
bool needShare = (id == MSG_SIM_OBTAIN_ICC_FILE_DONE);
std::unique_ptr<ControllerToFileMsg> objectUnique = nullptr;
std::shared_ptr<ControllerToFileMsg> objectShare = nullptr;
TELEPHONY_LOGI("IccFileController::SendResponse start response %{public}d %{public}d", isNull, needShare);
TELEPHONY_LOGD("IccFileController::SendResponse start response %{public}d %{public}d", isNull, needShare);
if (needShare) {
objectShare = std::make_shared<ControllerToFileMsg>(cmdData.get(), fd);
} else {
@ -446,13 +446,13 @@ void IccFileController::SendResponse(std::shared_ptr<IccControllerHolder> holder
}
isNull = (owner == nullptr);
TELEPHONY_LOGI("IccFileController::SendResponse owner: %{public}d evtId: %{public}d", isNull, id);
TELEPHONY_LOGD("IccFileController::SendResponse owner: %{public}d evtId: %{public}d", isNull, id);
if (needShare) {
owner->SendEvent(id, objectShare);
} else {
owner->SendEvent(id, objectUnique);
}
TELEPHONY_LOGI("IccFileController::SendResponse send end");
TELEPHONY_LOGD("IccFileController::SendResponse send end");
}
void IccFileController::SendEfLinearResult(const AppExecFwk::InnerEvent::Pointer &response, const int val[], int len)
@ -536,13 +536,13 @@ AppExecFwk::InnerEvent::Pointer IccFileController::BuildCallerInfo(
std::shared_ptr<IccControllerHolder> ctrlHolder = std::make_shared<IccControllerHolder>(arg1);
ctrlHolder->fileLoaded = std::move(const_cast<AppExecFwk::InnerEvent::Pointer &>(msg));
bool isNull = ctrlHolder->fileLoaded->GetOwner() == nullptr;
TELEPHONY_LOGI("IccFileController::BuildCallerInfo stage init owner: %{public}d", isNull);
TELEPHONY_LOGD("IccFileController::BuildCallerInfo stage init owner: %{public}d", isNull);
std::unique_ptr<IccToRilMsg> msgTo = std::make_unique<IccToRilMsg>(ctrlHolder);
if (msgTo == nullptr) {
TELEPHONY_LOGE("IccFileController::BuildCallerInfo3 create null pointer");
return AppExecFwk::InnerEvent::Pointer(nullptr, nullptr);
}
TELEPHONY_LOGI("IccFileController::BuildCallerInfo stage end");
TELEPHONY_LOGD("IccFileController::BuildCallerInfo stage end");
msgTo->arg1 = arg1;
msgTo->arg2 = arg2;
int64_t eventParam = 0;
@ -567,7 +567,7 @@ void IccFileController::ParseFileSize(int val[], int len, const unsigned char *d
val[MAX_FILE_INDEX] = val[1] / val[0];
}
}
TELEPHONY_LOGI("ParseFileSize result %{public}d, %{public}d %{public}d", val[0], val[1], val[MAX_FILE_INDEX]);
TELEPHONY_LOGD("ParseFileSize result %{public}d, %{public}d %{public}d", val[0], val[1], val[MAX_FILE_INDEX]);
}
bool IccFileController::IsValidSizeData(const unsigned char *data)
{
@ -625,7 +625,7 @@ bool IccFileController::ProcessErrorResponse(const AppExecFwk::InnerEvent::Point
bool needShare = (id == MSG_SIM_OBTAIN_ICC_FILE_DONE);
std::unique_ptr<ControllerToFileMsg> objectUnique = nullptr;
std::shared_ptr<ControllerToFileMsg> objectShare = nullptr;
TELEPHONY_LOGI("ProcessErrorResponse start response %{public}d", needShare);
TELEPHONY_LOGD("ProcessErrorResponse start response %{public}d", needShare);
if (needShare) {
objectShare = std::make_shared<ControllerToFileMsg>(cmdData.get(), nullptr);
objectShare->exception = rcvMsg->fileData.exception;
@ -645,7 +645,7 @@ bool IccFileController::ProcessErrorResponse(const AppExecFwk::InnerEvent::Point
} else {
owner->SendEvent(id, objectUnique);
}
TELEPHONY_LOGI("ProcessErrorResponse send end");
TELEPHONY_LOGD("ProcessErrorResponse send end");
return true;
}

14
services/sim/src/operator_file_parser.cpp
View File

@ -134,7 +134,7 @@ bool OperatorFileParser::ParseOperatorConfigFromFile(OperatorConfig &opc, const
void OperatorFileParser::ParseOperatorConfigFromJson(const Json::Value &root, OperatorConfig &opc)
{
TELEPHONY_LOGI("ParseOperatorConfigFromJson");
TELEPHONY_LOGD("ParseOperatorConfigFromJson");
Json::Value::Members mems = root.getMemberNames();
std::map<std::u16string, std::u16string> &configValue = opc.configValue;
for (auto mem : mems) {
@ -145,33 +145,33 @@ void OperatorFileParser::ParseOperatorConfigFromJson(const Json::Value &root, Op
value.toStyledString().c_str());
auto valueType = root[mem].type();
if (valueType == Json::arrayValue) {
TELEPHONY_LOGI("parse type arrayValue");
TELEPHONY_LOGD("parse type arrayValue");
if (value.size() > 0) {
ParseArray(keyStr8, value, opc);
}
continue;
}
if (valueType == Json::stringValue) {
TELEPHONY_LOGI("parse type stringValue");
TELEPHONY_LOGD("parse type stringValue");
opc.stringValue[keyStr8] = value.asString();
configValue[Str8ToStr16(keyStr8)] = Str8ToStr16(value.asString());
continue;
}
if (valueType == Json::intValue) {
TELEPHONY_LOGI("parse type initValue");
TELEPHONY_LOGD("parse type initValue");
int64_t lValue = static_cast<int64_t>(stoll(value.asString()));
configValue[Str8ToStr16(keyStr8)] = Str8ToStr16(value.asString());
if (value > INT_MAX) {
TELEPHONY_LOGI("value is long");
TELEPHONY_LOGD("value is long");
opc.longValue[keyStr8] = lValue;
} else {
TELEPHONY_LOGI("value is int");
TELEPHONY_LOGD("value is int");
opc.intValue[keyStr8] = static_cast<int32_t>(lValue);
}
continue;
}
if (valueType == Json::booleanValue) {
TELEPHONY_LOGI("parse type booleanValue");
TELEPHONY_LOGD("parse type booleanValue");
opc.boolValue[keyStr8] = value.asBool();
configValue[Str8ToStr16(keyStr8)] = Str8ToStr16(value.asString());
continue;

2
services/sim/src/sim_state_handle.cpp
View File

@ -75,7 +75,7 @@ bool SimStateHandle::HasSimCard()
if (iccState_.simStatus_ != ICC_CARD_ABSENT) {
has = true;
}
TELEPHONY_LOGI("SimStateHandle::HasSimCard(), has = %{public}d", has);
TELEPHONY_LOGD("SimStateHandle::HasSimCard(), has = %{public}d", has);
return has;
}

20
services/sim/src/sim_state_manager.cpp
View File

@ -107,7 +107,7 @@ CardType SimStateManager::GetCardType()
CardType ret = CardType::UNKNOWN_CARD;
if (simStateHandle_ != nullptr) {
std::lock_guard<std::mutex> lck(mtx_);
TELEPHONY_LOGI("SimStateManager::GetCardType()");
TELEPHONY_LOGD("SimStateManager::GetCardType()");
ret = simStateHandle_->GetCardType();
}
return ret;
@ -120,7 +120,7 @@ int32_t SimStateManager::UnlockPin(int32_t slotId, const std::string &pin, LockS
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
std::unique_lock<std::mutex> lck(ctx_);
TELEPHONY_LOGI("SimStateManager::UnlockPin()");
TELEPHONY_LOGD("SimStateManager::UnlockPin()");
responseReady_ = false;
simStateHandle_->UnlockPin(slotId, pin);
while (!responseReady_) {
@ -154,7 +154,7 @@ int32_t SimStateManager::UnlockPuk(
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
std::unique_lock<std::mutex> lck(ctx_);
TELEPHONY_LOGI("SimStateManager::UnlockPuk()");
TELEPHONY_LOGD("SimStateManager::UnlockPuk()");
responseReady_ = false;
simStateHandle_->UnlockPuk(slotId, newPin, puk);
while (!responseReady_) {
@ -188,7 +188,7 @@ int32_t SimStateManager::AlterPin(
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
std::unique_lock<std::mutex> lck(ctx_);
TELEPHONY_LOGI("SimStateManager::AlterPin()");
TELEPHONY_LOGD("SimStateManager::AlterPin()");
responseReady_ = false;
simStateHandle_->AlterPin(slotId, newPin, oldPin);
while (!responseReady_) {
@ -231,7 +231,7 @@ int32_t SimStateManager::SetLockState(int32_t slotId, const LockInfo &options, L
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
std::unique_lock<std::mutex> lck(ctx_);
TELEPHONY_LOGI("SimStateManager::SetLockState()");
TELEPHONY_LOGD("SimStateManager::SetLockState()");
responseReady_ = false;
simStateHandle_->SetLockState(slotId, options);
while (!responseReady_) {
@ -270,7 +270,7 @@ int32_t SimStateManager::GetLockState(int32_t slotId, LockType lockType, LockSta
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
std::unique_lock<std::mutex> lck(ctx_);
TELEPHONY_LOGI("SimStateManager::GetLockState()");
TELEPHONY_LOGD("SimStateManager::GetLockState()");
responseReady_ = false;
simStateHandle_->GetLockState(slotId, lockType);
while (!responseReady_) {
@ -305,7 +305,7 @@ int32_t SimStateManager::UnlockPin2(int32_t slotId, const std::string &pin2, Loc
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
std::unique_lock<std::mutex> lck(ctx_);
TELEPHONY_LOGI("SimStateManager::UnlockPin2()");
TELEPHONY_LOGD("SimStateManager::UnlockPin2()");
responseReady_ = false;
simStateHandle_->UnlockPin2(slotId, pin2);
while (!responseReady_) {
@ -339,7 +339,7 @@ int32_t SimStateManager::UnlockPuk2(
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
std::unique_lock<std::mutex> lck(ctx_);
TELEPHONY_LOGI("SimStateManager::UnlockPuk2()");
TELEPHONY_LOGD("SimStateManager::UnlockPuk2()");
responseReady_ = false;
simStateHandle_->UnlockPuk2(slotId, newPin2, puk2);
while (!responseReady_) {
@ -373,7 +373,7 @@ int32_t SimStateManager::AlterPin2(
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
std::unique_lock<std::mutex> lck(ctx_);
TELEPHONY_LOGI("SimStateManager::AlterPin2()");
TELEPHONY_LOGD("SimStateManager::AlterPin2()");
responseReady_ = false;
simStateHandle_->AlterPin2(slotId, newPin2, oldPin2);
while (!responseReady_) {
@ -426,7 +426,7 @@ int32_t SimStateManager::UnlockSimLock(int32_t slotId, const PersoLockInfo &lock
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
std::unique_lock<std::mutex> lck(ctx_);
TELEPHONY_LOGI("SimStateManager::UnlockSimLock()");
TELEPHONY_LOGD("SimStateManager::UnlockSimLock()");
responseReady_ = false;
simStateHandle_->UnlockSimLock(slotId, lockInfo);
while (!responseReady_) {

6
services/tel_ril/include/tel_ril_base.h
View File

@ -200,7 +200,7 @@ inline int32_t TelRilBase::SendEventData(
TELEPHONY_LOGE("func %{public}s Send eventId:%{public}d is failed!", funcName, eventId);
return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
}
TELEPHONY_LOGI("func %{public}s Send eventId:%{public}d finish", funcName, eventId);
TELEPHONY_LOGD("func %{public}s Send eventId:%{public}d finish", funcName, eventId);
return TELEPHONY_ERR_SUCCESS;
}
@ -211,7 +211,7 @@ inline int32_t TelRilBase::Notify(const char *funcName, std::shared_ptr<T> data,
TELEPHONY_LOGE("%{public}s() observerHandler_ or data is nullptr", funcName);
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
TELEPHONY_LOGI("%{public}s() notify event %{public}d notifyId slotId:%{public}d", funcName, notifyId, slotId_);
TELEPHONY_LOGD("%{public}s() notify event %{public}d notifyId slotId:%{public}d", funcName, notifyId, slotId_);
observerHandler_->NotifyObserver(notifyId, data);
return TELEPHONY_ERR_SUCCESS;
}
@ -222,7 +222,7 @@ inline int32_t TelRilBase::Notify(const char *funcName, RadioEvent notifyId)
TELEPHONY_LOGE("%{public}s() observerHandler_ is nullptr", funcName);
return TELEPHONY_ERR_LOCAL_PTR_NULL;
}
TELEPHONY_LOGI("%{public}s() notify event %{public}d notifyId slotId:%{public}d", funcName, notifyId, slotId_);
TELEPHONY_LOGD("%{public}s() notify event %{public}d notifyId slotId:%{public}d", funcName, notifyId, slotId_);
observerHandler_->NotifyObserver(notifyId);
return TELEPHONY_ERR_SUCCESS;
}

8
services/tel_ril/src/observer_handler.cpp
View File

@ -33,10 +33,10 @@ void ObserverHandler::RegObserver(int32_t what, const std::shared_ptr<AppExecFwk
if (it == handlers.end()) {
handlers.push_back(handler);
}
TELEPHONY_LOGI("ObserverHandler RegObserver update callback what: %{public}d, list size: %{public}zu", what,
TELEPHONY_LOGD("ObserverHandler RegObserver update callback what: %{public}d, list size: %{public}zu", what,
handlers.size());
} else {
TELEPHONY_LOGI("ObserverHandler RegObserver callback what: %{public}d", what);
TELEPHONY_LOGD("ObserverHandler RegObserver callback what: %{public}d", what);
std::list<std::shared_ptr<AppExecFwk::EventHandler>> handlers;
handlers.push_back(handler);
observerHandlerMap_.emplace(what, handlers);
@ -64,7 +64,7 @@ void ObserverHandler::Remove(int32_t what, const std::shared_ptr<AppExecFwk::Eve
if (it != handlers.end()) {
handlers.erase(it);
}
TELEPHONY_LOGI("ObserverHandler Remove handlers list: %{public}zu", handlers.size());
TELEPHONY_LOGD("ObserverHandler Remove handlers list: %{public}zu", handlers.size());
}
}
@ -78,7 +78,7 @@ void ObserverHandler::NotifyObserver(int32_t what)
}
for (auto handler : iter->second) {
TELEPHONY_LOGI("handler->SendEvent:%{public}d", what);
TELEPHONY_LOGD("handler->SendEvent:%{public}d", what);
handler->SendEvent(what);
}
}

2
services/tel_ril/src/tel_ril_base.cpp
View File

@ -65,7 +65,7 @@ std::shared_ptr<TelRilRequest> TelRilBase::FindTelRilRequest(const HRilRadioResp
std::lock_guard<std::mutex> lockRequest(TelRilBase::requestLock_);
auto iter = TelRilBase::requestMap_.find(serial);
if (iter == TelRilBase::requestMap_.end()) {
TELEPHONY_LOGI("FindTelRilRequest not found serial:%{public}d", serial);
TELEPHONY_LOGD("FindTelRilRequest not found serial:%{public}d", serial);
} else {
telRilRequest = iter->second;
if (handler_ != nullptr) {

2
services/tel_ril/src/tel_ril_data.cpp
View File

@ -176,7 +176,7 @@ int32_t TelRilData::SetLinkBandwidthReportingRule(
dLinkBandwidth.maximumDownlinkKbpsSize = static_cast<int32_t>(linkBandwidth.maximumDownlinkKbps.size());
dLinkBandwidth.maximumUplinkKbps = linkBandwidth.maximumUplinkKbps;
dLinkBandwidth.maximumDownlinkKbps = linkBandwidth.maximumDownlinkKbps;
TELEPHONY_LOGI("maximumUplinkKbpsSize:%{public}d, maximumDownlinkKbpsSize:%{public}d",
TELEPHONY_LOGD("maximumUplinkKbpsSize:%{public}d, maximumDownlinkKbpsSize:%{public}d",
dLinkBandwidth.maximumUplinkKbpsSize, dLinkBandwidth.maximumDownlinkKbpsSize);
return Request(TELEPHONY_LOG_FUNC_NAME, response, HREQ_DATA_SET_LINK_BANDWIDTH_REPORTING_RULE,
&HDI::Ril::V1_0::IRil::SetLinkBandwidthReportingRule, dLinkBandwidth);

16
services/tel_ril/src/tel_ril_handler.cpp
View File

@ -27,19 +27,19 @@ void TelRilHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event)
}
auto id = event->GetInnerEventId();
auto serial = event->GetParam();
TELEPHONY_LOGI(
TELEPHONY_LOGD(
"ProcessEvent, id:%{public}d, serial:%{public}d, reqLockSerialNum_:%{public}d, ackLockSerialNum_:%{public}d",
id, static_cast<int>(serial), static_cast<int>(reqLockSerialNum_), static_cast<int>(ackLockSerialNum_));
switch (id) {
case RUNNING_LOCK_TIMEOUT_EVENT_ID:
if (serial == reqLockSerialNum_) {
TELEPHONY_LOGI("Running lock timeout, release running lock!!!");
TELEPHONY_LOGD("Running lock timeout, release running lock!!!");
ReleaseRunningLock(NORMAL_RUNNING_LOCK);
}
break;
case ACK_RUNNING_LOCK_TIMEOUT_EVENT_ID:
if (serial == ackLockSerialNum_) {
TELEPHONY_LOGI("Ack Running lock timeout, release running lock!!!");
TELEPHONY_LOGD("Ack Running lock timeout, release running lock!!!");
ReleaseRunningLock(ACK_RUNNING_LOCK);
}
break;
@ -81,7 +81,7 @@ void TelRilHandler::ApplyRunningLock(int32_t lockType)
reqRunningLockCount_++;
reqLockSerialNum_++;
reqRunningLock_->Lock();
TELEPHONY_LOGI("ApplyRunningLock,reqLockSerialNum_:%{public}d", static_cast<int>(reqLockSerialNum_));
TELEPHONY_LOGD("ApplyRunningLock, reqLockSerialNum_:%{public}d", static_cast<int>(reqLockSerialNum_));
this->SendEvent(RUNNING_LOCK_TIMEOUT_EVENT_ID, reqLockSerialNum_, RUNNING_LOCK_DEFAULT_TIMEOUT_MS);
} else if (ackRunningLock_ != nullptr && lockType == ACK_RUNNING_LOCK) {
ackLockSerialNum_++;
@ -89,20 +89,20 @@ void TelRilHandler::ApplyRunningLock(int32_t lockType)
TELEPHONY_LOGI("ApplyRunningLock,ackLockSerialNum_:%{public}d", static_cast<int>(ackLockSerialNum_));
this->SendEvent(ACK_RUNNING_LOCK_TIMEOUT_EVENT_ID, ackLockSerialNum_, ACK_RUNNING_LOCK_DEFAULT_TIMEOUT_MS);
} else {
TELEPHONY_LOGE("ApplyRunningLock,lockType:%{public}d is invalid", lockType);
TELEPHONY_LOGE("ApplyRunningLock, lockType:%{public}d is invalid", lockType);
}
}
void TelRilHandler::ReduceRunningLock(int32_t lockType)
{
std::lock_guard<std::mutex> lockRequest(mutexRunningLock_);
TELEPHONY_LOGI("ReduceRunningLock,reqRunningLockCount_:%{public}d", static_cast<int>(reqRunningLockCount_));
TELEPHONY_LOGD("ReduceRunningLock, reqRunningLockCount_:%{public}d", static_cast<int>(reqRunningLockCount_));
if ((reqRunningLock_ != nullptr) && (lockType == NORMAL_RUNNING_LOCK)) {
if (reqRunningLockCount_ > 1) {
reqRunningLockCount_--;
} else {
reqRunningLockCount_ = 0;
TELEPHONY_LOGI("ReduceRunningLock, UnLock");
TELEPHONY_LOGD("ReduceRunningLock, UnLock");
reqRunningLock_->UnLock();
}
} else {
@ -117,7 +117,7 @@ void TelRilHandler::ReleaseRunningLock(int32_t lockType)
return;
}
std::lock_guard<std::mutex> lockRequest(mutexRunningLock_);
TELEPHONY_LOGI("ReleaseRunningLock,lockType:%{public}d", lockType);
TELEPHONY_LOGD("ReleaseRunningLock, lockType:%{public}d", lockType);
if (lockType == NORMAL_RUNNING_LOCK) {
reqRunningLockCount_ = 0;
reqRunningLock_->UnLock();

14
services/tel_ril/src/tel_ril_manager.cpp
View File

@ -181,7 +181,7 @@ int32_t TelRilManager::RegisterCoreNotify(
}
break;
default:
TELEPHONY_LOGI("RegisterCoreNotify default what:%{public}d, slotId:%{public}d", what, slotId);
TELEPHONY_LOGD("RegisterCoreNotify default what:%{public}d, slotId:%{public}d", what, slotId);
observerHandler->RegObserver(what, observerCallBack);
break;
}
@ -428,7 +428,7 @@ int32_t TelRilManager::GetEmergencyCallList(int32_t slotId, const AppExecFwk::In
int32_t TelRilManager::SetEmergencyCallList(
int32_t slotId, const std::vector<EmergencyCall> &eccVec, const AppExecFwk::InnerEvent::Pointer &response)
{
TELEPHONY_LOGI("SetEmergencyCallList start");
TELEPHONY_LOGD("SetEmergencyCallList start");
return TaskSchedule(response, "TelRilCall", GetTelRilCall(slotId), &TelRilCall::SetEmergencyCallList, eccVec);
}
@ -808,7 +808,7 @@ int32_t TelRilManager::SetRadioProtocol(
void TelRilManager::HandleRilInterfaceStatusCallback(const OHOS::HDI::ServiceManager::V1_0::ServiceStatus &status)
{
TELEPHONY_LOGI("TelRilManager::HandleRilInterfaceCallback, service name %{public}s %{public}d",
TELEPHONY_LOGD("TelRilManager::HandleRilInterfaceCallback, service name %{public}s %{public}d",
status.serviceName.c_str(), status.status);
if (status.serviceName != std::string(RIL_INTERFACE_SERVICE_NAME)) {
return;
@ -878,7 +878,7 @@ bool TelRilManager::UnRegisterHdfStatusListener()
return false;
}
TELEPHONY_LOGI("TelRilManager::UnRegisterHdfStatusListener, unregister successfully!");
TELEPHONY_LOGD("TelRilManager::UnRegisterHdfStatusListener, unregister successfully!");
return true;
}
@ -898,14 +898,14 @@ bool TelRilManager::ReConnectRilInterface()
TELEPHONY_LOGE("TelRilManager::ReConnectRilInterface, Reset remote object failed!");
return false;
}
TELEPHONY_LOGI("TelRilManager::ReConnectRilInterface, Connect riladapter service successfully!");
TELEPHONY_LOGD("TelRilManager::ReConnectRilInterface, Connect riladapter service successfully!");
return true;
}
bool TelRilManager::DisConnectRilInterface()
{
if (rilInterface_ == nullptr) {
TELEPHONY_LOGI("TelRilManager::DisConnectRilInterface has been successfully disconnected!");
TELEPHONY_LOGD("TelRilManager::DisConnectRilInterface has been successfully disconnected!");
return true;
}
rilInterface_ = nullptr;
@ -913,7 +913,7 @@ bool TelRilManager::DisConnectRilInterface()
TELEPHONY_LOGE("TelRilManager::DisConnectRilInterface, Reset remote object failed!");
return false;
}
TELEPHONY_LOGI("TelRilManager::DisConnectRilInterface, disconnect riladapter service successfully");
TELEPHONY_LOGD("TelRilManager::DisConnectRilInterface, disconnect riladapter service successfully");
return true;
}
} // namespace Telephony

2
services/tel_ril/src/tel_ril_modem.cpp
View File

@ -128,7 +128,7 @@ int32_t TelRilModem::RadioStateUpdated(int32_t state)
commonEventData.SetWant(want);
EventFwk::CommonEventPublishInfo publishInfo;
bool retsult = EventFwk::CommonEventManager::PublishCommonEvent(commonEventData, publishInfo, nullptr);
TELEPHONY_LOGI("publish modem subscribed event result : %{public}d", retsult);
TELEPHONY_LOGD("publish modem subscribed event result : %{public}d", retsult);
return Notify<HRilInt32Parcel>(
TELEPHONY_LOG_FUNC_NAME, std::make_shared<HRilInt32Parcel>(state), RadioEvent::RADIO_STATE_CHANGED);
}

2
services/tel_ril/src/tel_ril_sms.cpp
View File

@ -276,7 +276,7 @@ int32_t TelRilSms::SmsStatusReportNotify(const HDI::Ril::V1_0::SmsMessageInfo &i
int32_t TelRilSms::NewSmsStoredOnSimNotify(int32_t recordNumber, int32_t indicationType)
{
TELEPHONY_LOGI("indicationType: %{public}d", indicationType);
TELEPHONY_LOGD("indicationType: %{public}d", indicationType);
return Notify<int32_t>(
TELEPHONY_LOG_FUNC_NAME, std::make_shared<int32_t>(recordNumber), RadioEvent::RADIO_SMS_ON_SIM);
}