diff --git a/aidl/ir/ConsumerIr.cpp b/aidl/ir/ConsumerIr.cpp
index 23c9ea5..aac4003 100644
--- a/aidl/ir/ConsumerIr.cpp
+++ b/aidl/ir/ConsumerIr.cpp
@@ -26,15 +26,15 @@ ConsumerIr::ConsumerIr() : supportedFreqs({{MIN_FREQ, MAX_FREQ}}) {}
     return ::ndk::ScopedAStatus::ok();
 }
 
-::ndk::ScopedAStatus ConsumerIr::transmit(int32_t in_carrierFreqHz,
-                                          const std::vector<int32_t>& in_pattern) {
-    if (in_carrierFreqHz < MIN_FREQ || in_carrierFreqHz > MAX_FREQ) {
-        LOG(ERROR) << "Invalid carrier frequency: " << in_carrierFreqHz;
+::ndk::ScopedAStatus ConsumerIr::transmit(int32_t carrierFreqHz,
+                                          const std::vector<int32_t>& pattern) {
+    if (carrierFreqHz < MIN_FREQ || carrierFreqHz > MAX_FREQ) {
+        LOG(ERROR) << "Invalid carrier frequency: " << carrierFreqHz;
         return ::ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
     }
 
     int32_t totalTime = 0;
-    for (int32_t value : in_pattern) {
+    for (int32_t value : pattern) {
         if (value < 0) {
             LOG(ERROR) << "Invalid pattern value: " << value;
             return ::ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
@@ -53,7 +53,7 @@ ConsumerIr::ConsumerIr() : supportedFreqs({{MIN_FREQ, MAX_FREQ}}) {}
         return ::ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
     }
 
-    size_t paramsSize = sizeof(struct pattern_params) + in_pattern.size() * sizeof(int32_t);
+    size_t paramsSize = sizeof(struct pattern_params) + pattern.size() * sizeof(int32_t);
     auto params = std::unique_ptr<struct pattern_params, decltype(&free)>(
             static_cast<pattern_params*>(malloc(paramsSize)), free);
     if (!params) {
@@ -61,9 +61,9 @@ ConsumerIr::ConsumerIr() : supportedFreqs({{MIN_FREQ, MAX_FREQ}}) {}
         return ::ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
     }
 
-    params->carrier_freq = in_carrierFreqHz;
-    params->size = in_pattern.size();
-    memcpy(params->pattern, in_pattern.data(), in_pattern.size() * sizeof(int32_t));
+    params->carrier_freq = carrierFreqHz;
+    params->size = pattern.size();
+    memcpy(params->pattern, pattern.data(), pattern.size() * sizeof(int32_t));
 
     int result = ioctl(fd, IR_SEND_PATTERN, params.get());
 
diff --git a/aidl/ir/ConsumerIr.h b/aidl/ir/ConsumerIr.h
index 0362470..29fa47e 100644
--- a/aidl/ir/ConsumerIr.h
+++ b/aidl/ir/ConsumerIr.h
@@ -18,8 +18,8 @@ class ConsumerIr : public BnConsumerIr {
 
   private:
     ::ndk::ScopedAStatus getCarrierFreqs(std::vector<ConsumerIrFreqRange>* _aidl_return) override;
-    ::ndk::ScopedAStatus transmit(int32_t in_carrierFreqHz,
-                                  const std::vector<int32_t>& in_pattern) override;
+    ::ndk::ScopedAStatus transmit(int32_t carrierFreqHz,
+                                  const std::vector<int32_t>& pattern) override;
 
     std::vector<ConsumerIrFreqRange> supportedFreqs;
 };
diff --git a/aidl/performance/Performance.cpp b/aidl/performance/Performance.cpp
index 56324b2..6d15591 100644
--- a/aidl/performance/Performance.cpp
+++ b/aidl/performance/Performance.cpp
@@ -15,56 +15,54 @@ namespace oplus {
 namespace hardware {
 namespace performance {
 
-ndk::ScopedAStatus Performance::addAcmDirName(const std::string& in_dirname, int64_t in_flag,
+ndk::ScopedAStatus Performance::addAcmDirName(const std::string& dirname, int64_t flag,
                                               int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": dirname=" << in_dirname << ", flag=" << in_flag;
+    LOG(INFO) << __func__ << ": dirname=" << dirname << ", flag=" << flag;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::addAcmNomediaDirName(const std::string& in_dirname,
+ndk::ScopedAStatus Performance::addAcmNomediaDirName(const std::string& dirname,
                                                      int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": dirname=" << in_dirname;
+    LOG(INFO) << __func__ << ": dirname=" << dirname;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::addAcmPkgName(const std::string& in_pkgname, int64_t in_flag,
+ndk::ScopedAStatus Performance::addAcmPkgName(const std::string& pkgname, int64_t flag,
                                               int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": pkgname=" << in_pkgname << ", flag=" << in_flag;
+    LOG(INFO) << __func__ << ": pkgname=" << pkgname << ", flag=" << flag;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::addTaskTrackPid(int32_t in_group, int32_t in_pid, bool in_clear,
+ndk::ScopedAStatus Performance::addTaskTrackPid(int32_t group, int32_t pid, bool clear,
                                                 int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": group=" << in_group << ", pid=" << in_pid << ", clear=" << in_clear;
+    LOG(INFO) << __func__ << ": group=" << group << ", pid=" << pid << ", clear=" << clear;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::clearTaskTrackGroup(int32_t in_group) {
-    LOG(INFO) << __func__ << ": group=" << in_group;
+ndk::ScopedAStatus Performance::clearTaskTrackGroup(int32_t group) {
+    LOG(INFO) << __func__ << ": group=" << group;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::delAcmDirName(const std::string& in_dirname,
-                                              int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": dirname=" << in_dirname;
+ndk::ScopedAStatus Performance::delAcmDirName(const std::string& dirname, int32_t* _aidl_return) {
+    LOG(INFO) << __func__ << ": dirname=" << dirname;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::delAcmNomediaDirName(const std::string& in_dirname,
+ndk::ScopedAStatus Performance::delAcmNomediaDirName(const std::string& dirname,
                                                      int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": dirname=" << in_dirname;
+    LOG(INFO) << __func__ << ": dirname=" << dirname;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::delAcmPkgName(const std::string& in_pkgname,
-                                              int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": pkgname=" << in_pkgname;
+ndk::ScopedAStatus Performance::delAcmPkgName(const std::string& pkgname, int32_t* _aidl_return) {
+    LOG(INFO) << __func__ << ": pkgname=" << pkgname;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
@@ -111,9 +109,8 @@ ndk::ScopedAStatus Performance::disableVmallocDebug(int32_t* _aidl_return) {
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::enableAudioPerf(const std::string& in_value,
-                                                int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": value=" << in_value;
+ndk::ScopedAStatus Performance::enableAudioPerf(const std::string& value, int32_t* _aidl_return) {
+    LOG(INFO) << __func__ << ": value=" << value;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
@@ -166,9 +163,8 @@ ndk::ScopedAStatus Performance::existMemMonitor(int32_t* _aidl_return) {
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::getAcmDirFlag(const std::string& in_dirname,
-                                              int64_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": dirname=" << in_dirname;
+ndk::ScopedAStatus Performance::getAcmDirFlag(const std::string& dirname, int64_t* _aidl_return) {
+    LOG(INFO) << __func__ << ": dirname=" << dirname;
     *_aidl_return = 0L;
     return ndk::ScopedAStatus::ok();
 }
@@ -179,9 +175,8 @@ ndk::ScopedAStatus Performance::getAcmOpstat(int32_t* _aidl_return) {
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::getAcmPkgFlag(const std::string& in_pkgname,
-                                              int64_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": pkgname=" << in_pkgname;
+ndk::ScopedAStatus Performance::getAcmPkgFlag(const std::string& pkgname, int64_t* _aidl_return) {
+    LOG(INFO) << __func__ << ": pkgname=" << pkgname;
     *_aidl_return = 0L;
     return ndk::ScopedAStatus::ok();
 }
@@ -192,9 +187,8 @@ ndk::ScopedAStatus Performance::getClmMuxSwitch(std::string* _aidl_return) {
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::getClmThreshold(int32_t in_threshold_id,
-                                                std::string* _aidl_return) {
-    LOG(INFO) << __func__ << ": threshold_id=" << in_threshold_id;
+ndk::ScopedAStatus Performance::getClmThreshold(int32_t threshold_id, std::string* _aidl_return) {
+    LOG(INFO) << __func__ << ": threshold_id=" << threshold_id;
     *_aidl_return = "";
     return ndk::ScopedAStatus::ok();
 }
@@ -223,16 +217,16 @@ ndk::ScopedAStatus Performance::getDevinfoUfsVersionInfo(std::string* _aidl_retu
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::getExt4FragScore(const std::string& in_devpath,
+ndk::ScopedAStatus Performance::getExt4FragScore(const std::string& devpath,
                                                  std::string* _aidl_return) {
-    LOG(INFO) << __func__ << ": devpath=" << in_devpath;
+    LOG(INFO) << __func__ << ": devpath=" << devpath;
     *_aidl_return = "";
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::getExt4FreefragInfo(const std::string& in_devpath,
+ndk::ScopedAStatus Performance::getExt4FreefragInfo(const std::string& devpath,
                                                     std::string* _aidl_return) {
-    LOG(INFO) << __func__ << ": devpath=" << in_devpath;
+    LOG(INFO) << __func__ << ": devpath=" << devpath;
     *_aidl_return = "";
     return ndk::ScopedAStatus::ok();
 }
@@ -393,10 +387,10 @@ ndk::ScopedAStatus Performance::getVmallocUsed(std::string* _aidl_return) {
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::getWakeThreadsAffinityOrdered(const std::string& in_handle,
-                                                              int32_t in_size,
+ndk::ScopedAStatus Performance::getWakeThreadsAffinityOrdered(const std::string& handle,
+                                                              int32_t size,
                                                               TaskWakeInfo* _aidl_return) {
-    LOG(INFO) << __func__ << ": handle=" << in_handle << ", size=" << in_size;
+    LOG(INFO) << __func__ << ": handle=" << handle << ", size=" << size;
     *_aidl_return = {};
     return ndk::ScopedAStatus::ok();
 }
@@ -437,35 +431,33 @@ ndk::ScopedAStatus Performance::getschedlatency(std::string* _aidl_return) {
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::hybridswap_memcg_para_read(int32_t in_action,
-                                                           const std::string& in_cgroup,
+ndk::ScopedAStatus Performance::hybridswap_memcg_para_read(int32_t action,
+                                                           const std::string& cgroup,
                                                            std::string* _aidl_return) {
-    LOG(INFO) << __func__ << ": action=" << in_action << ", cgroup=" << in_cgroup;
+    LOG(INFO) << __func__ << ": action=" << action << ", cgroup=" << cgroup;
     *_aidl_return = "";
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::hybridswap_memcg_para_write(int32_t in_action,
-                                                            const std::string& in_cgroup,
-                                                            const std::string& in_str,
+ndk::ScopedAStatus Performance::hybridswap_memcg_para_write(int32_t action,
+                                                            const std::string& cgroup,
+                                                            const std::string& str,
                                                             int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": action=" << in_action << ", cgroup=" << in_cgroup
-              << ", str=" << in_str;
+    LOG(INFO) << __func__ << ": action=" << action << ", cgroup=" << cgroup << ", str=" << str;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::hybridswap_zram_para_read(int32_t in_action,
+ndk::ScopedAStatus Performance::hybridswap_zram_para_read(int32_t action,
                                                           std::string* _aidl_return) {
-    LOG(INFO) << __func__ << ": action=" << in_action;
+    LOG(INFO) << __func__ << ": action=" << action;
     *_aidl_return = "";
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::hybridswap_zram_para_write(int32_t in_action,
-                                                           const std::string& in_str,
+ndk::ScopedAStatus Performance::hybridswap_zram_para_write(int32_t action, const std::string& str,
                                                            int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": action=" << in_action << ", str=" << in_str;
+    LOG(INFO) << __func__ << ": action=" << action << ", str=" << str;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
@@ -476,16 +468,16 @@ ndk::ScopedAStatus Performance::isJankTaskTrackEnable(bool* _aidl_return) {
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::perProcessMemReadahead(int32_t in_uid, int32_t in_pid,
-                                                       int32_t in_type, int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": uid=" << in_uid << ", pid=" << in_pid << ", type=" << in_type;
+ndk::ScopedAStatus Performance::perProcessMemReadahead(int32_t uid, int32_t pid, int32_t type,
+                                                       int32_t* _aidl_return) {
+    LOG(INFO) << __func__ << ": uid=" << uid << ", pid=" << pid << ", type=" << type;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::perProcessMemReclaim(int32_t in_uid, int32_t in_pid,
-                                                     int32_t in_type, int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": uid=" << in_uid << ", pid=" << in_pid << ", type=" << in_type;
+ndk::ScopedAStatus Performance::perProcessMemReclaim(int32_t uid, int32_t pid, int32_t type,
+                                                     int32_t* _aidl_return) {
+    LOG(INFO) << __func__ << ": uid=" << uid << ", pid=" << pid << ", type=" << type;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
@@ -550,9 +542,9 @@ ndk::ScopedAStatus Performance::readIOBacktrace(std::string* _aidl_return) {
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::readIomonitorInfo(const std::string& in_procname,
+ndk::ScopedAStatus Performance::readIomonitorInfo(const std::string& procname,
                                                   std::string* _aidl_return) {
-    LOG(INFO) << __func__ << ": procname=" << in_procname;
+    LOG(INFO) << __func__ << ": procname=" << procname;
     *_aidl_return = "";
     return ndk::ScopedAStatus::ok();
 }
@@ -599,8 +591,8 @@ ndk::ScopedAStatus Performance::readJankTaskTrack(std::string* _aidl_return) {
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::readJankTaskTrackByPid(int32_t in_pid, std::string* _aidl_return) {
-    LOG(INFO) << __func__ << ": pid=" << in_pid;
+ndk::ScopedAStatus Performance::readJankTaskTrackByPid(int32_t pid, std::string* _aidl_return) {
+    LOG(INFO) << __func__ << ": pid=" << pid;
     *_aidl_return = "";
     return ndk::ScopedAStatus::ok();
 }
@@ -629,23 +621,23 @@ ndk::ScopedAStatus Performance::readMemleakDetectThread(std::string* _aidl_retur
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::readMemoryByPids(const std::vector<int32_t>& in_pids,
-                                                 int32_t in_flags, ProcMemStatRet* _aidl_return) {
-    LOG(INFO) << __func__ << ": pids.size=" << in_pids.size() << ", flags=" << in_flags;
+ndk::ScopedAStatus Performance::readMemoryByPids(const std::vector<int32_t>& pids, int32_t flags,
+                                                 ProcMemStatRet* _aidl_return) {
+    LOG(INFO) << __func__ << ": pids.size=" << pids.size() << ", flags=" << flags;
     *_aidl_return = {};
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::readMemoryByUids(const std::vector<int32_t>& in_uids,
-                                                 int32_t in_flags, ProcMemStatRet* _aidl_return) {
-    LOG(INFO) << __func__ << ": uids.size=" << in_uids.size() << ", flags=" << in_flags;
+ndk::ScopedAStatus Performance::readMemoryByUids(const std::vector<int32_t>& uids, int32_t flags,
+                                                 ProcMemStatRet* _aidl_return) {
+    LOG(INFO) << __func__ << ": uids.size=" << uids.size() << ", flags=" << flags;
     *_aidl_return = {};
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::readNandswapProc(const std::string& in_inProc,
+ndk::ScopedAStatus Performance::readNandswapProc(const std::string& inProc,
                                                  std::string* _aidl_return) {
-    LOG(INFO) << __func__ << ": inProc=" << in_inProc;
+    LOG(INFO) << __func__ << ": inProc=" << inProc;
     *_aidl_return = "";
     return ndk::ScopedAStatus::ok();
 }
@@ -662,9 +654,9 @@ ndk::ScopedAStatus Performance::readNormalizeRunningTime(std::string* _aidl_retu
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::readOplusReserve3(int32_t in_offset, int32_t in_len,
+ndk::ScopedAStatus Performance::readOplusReserve3(int32_t offset, int32_t len,
                                                   std::string* _aidl_return) {
-    LOG(INFO) << __func__ << ": offset=" << in_offset << ", len=" << in_len;
+    LOG(INFO) << __func__ << ": offset=" << offset << ", len=" << len;
     *_aidl_return = "";
     return ndk::ScopedAStatus::ok();
 }
@@ -711,19 +703,17 @@ ndk::ScopedAStatus Performance::readSgeInfo(std::string* _aidl_return) {
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::readStorageFeature(const std::string& in_name,
-                                                   const std::string& in_addr,
-                                                   const std::string& in_isMulti,
+ndk::ScopedAStatus Performance::readStorageFeature(const std::string& name, const std::string& addr,
+                                                   const std::string& isMulti,
                                                    std::string* _aidl_return) {
-    LOG(INFO) << __func__ << ": name=" << in_name << ", addr=" << in_addr
-              << ", isMulti=" << in_isMulti;
+    LOG(INFO) << __func__ << ": name=" << name << ", addr=" << addr << ", isMulti=" << isMulti;
     *_aidl_return = "";
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::readTargetProcess(const std::string& in_buffer,
+ndk::ScopedAStatus Performance::readTargetProcess(const std::string& buffer,
                                                   std::string* _aidl_return) {
-    LOG(INFO) << __func__ << ": buffer=" << in_buffer;
+    LOG(INFO) << __func__ << ": buffer=" << buffer;
     *_aidl_return = "";
     return ndk::ScopedAStatus::ok();
 }
@@ -770,9 +760,9 @@ ndk::ScopedAStatus Performance::readTmemorySysdirtypages(std::string* _aidl_retu
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::readUxTaskTrack(int32_t in_uPid, int32_t in_rPid,
+ndk::ScopedAStatus Performance::readUxTaskTrack(int32_t uPid, int32_t rPid,
                                                 std::string* _aidl_return) {
-    LOG(INFO) << __func__ << ": uPid=" << in_uPid << ", rPid=" << in_rPid;
+    LOG(INFO) << __func__ << ": uPid=" << uPid << ", rPid=" << rPid;
     *_aidl_return = "";
     return ndk::ScopedAStatus::ok();
 }
@@ -789,311 +779,295 @@ ndk::ScopedAStatus Performance::readVersion(std::string* _aidl_return) {
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::removeTaskTrackPid(int32_t in_group, int32_t in_pid) {
-    LOG(INFO) << __func__ << ": group=" << in_group << ", pid=" << in_pid;
+ndk::ScopedAStatus Performance::removeTaskTrackPid(int32_t group, int32_t pid) {
+    LOG(INFO) << __func__ << ": group=" << group << ", pid=" << pid;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::searchAcmNomediaDirName(const std::string& in_dirname,
+ndk::ScopedAStatus Performance::searchAcmNomediaDirName(const std::string& dirname,
                                                         int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": dirname=" << in_dirname;
+    LOG(INFO) << __func__ << ": dirname=" << dirname;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::setAcmOpstat(int32_t in_flag, int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": flag=" << in_flag;
+ndk::ScopedAStatus Performance::setAcmOpstat(int32_t flag, int32_t* _aidl_return) {
+    LOG(INFO) << __func__ << ": flag=" << flag;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::setClmMuxSwitch(const std::string& in_buffer) {
-    LOG(INFO) << __func__ << ": buffer=" << in_buffer;
+ndk::ScopedAStatus Performance::setClmMuxSwitch(const std::string& buffer) {
+    LOG(INFO) << __func__ << ": buffer=" << buffer;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::setClmThreshold(const std::string& in_buffer,
-                                                int32_t in_threshold_id) {
-    LOG(INFO) << __func__ << ": buffer=" << in_buffer << ", threshold_id=" << in_threshold_id;
+ndk::ScopedAStatus Performance::setClmThreshold(const std::string& buffer, int32_t threshold_id) {
+    LOG(INFO) << __func__ << ": buffer=" << buffer << ", threshold_id=" << threshold_id;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::setDamonReclaimColdTime(int32_t in_cold_time,
-                                                        int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": cold_time=" << in_cold_time;
+ndk::ScopedAStatus Performance::setDamonReclaimColdTime(int32_t cold_time, int32_t* _aidl_return) {
+    LOG(INFO) << __func__ << ": cold_time=" << cold_time;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::setDamonReclaimMonitoring(int32_t in_sample, int32_t in_aggr,
+ndk::ScopedAStatus Performance::setDamonReclaimMonitoring(int32_t sample, int32_t aggr,
                                                           int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": sample=" << in_sample << ", aggr=" << in_aggr;
+    LOG(INFO) << __func__ << ": sample=" << sample << ", aggr=" << aggr;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::setDamonReclaimQuota(int32_t in_quota_ms, int32_t in_quota_sz,
-                                                     int32_t in_reset_interval,
+ndk::ScopedAStatus Performance::setDamonReclaimQuota(int32_t quota_ms, int32_t quota_sz,
+                                                     int32_t reset_interval,
                                                      int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": quota_ms=" << in_quota_ms << ", quota_sz=" << in_quota_sz
-              << ", reset_interval=" << in_reset_interval;
+    LOG(INFO) << __func__ << ": quota_ms=" << quota_ms << ", quota_sz=" << quota_sz
+              << ", reset_interval=" << reset_interval;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::setDamonReclaimWmarks(int32_t in_metric, int32_t in_high,
-                                                      int32_t in_mid, int32_t in_low,
-                                                      int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": metric=" << in_metric << ", high=" << in_high << ", mid=" << in_mid
-              << ", low=" << in_low;
+ndk::ScopedAStatus Performance::setDamonReclaimWmarks(int32_t metric, int32_t high, int32_t mid,
+                                                      int32_t low, int32_t* _aidl_return) {
+    LOG(INFO) << __func__ << ": metric=" << metric << ", high=" << high << ", mid=" << mid
+              << ", low=" << low;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::setExtSchedProp(const std::string& in_pid,
-                                                const std::string& in_prop) {
-    LOG(INFO) << __func__ << ": pid=" << in_pid << ", prop=" << in_prop;
+ndk::ScopedAStatus Performance::setExtSchedProp(const std::string& pid, const std::string& prop) {
+    LOG(INFO) << __func__ << ": pid=" << pid << ", prop=" << prop;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::setFgUids(const std::string& in_fg_uid) {
-    LOG(INFO) << __func__ << ": fg_uid=" << in_fg_uid;
+ndk::ScopedAStatus Performance::setFgUids(const std::string& fg_uid) {
+    LOG(INFO) << __func__ << ": fg_uid=" << fg_uid;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::setFrameRate(const std::string& in_frame_rate) {
-    LOG(INFO) << __func__ << ": frame_rate=" << in_frame_rate;
+ndk::ScopedAStatus Performance::setFrameRate(const std::string& frame_rate) {
+    LOG(INFO) << __func__ << ": frame_rate=" << frame_rate;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::setFreqGoverner(const std::string& in_gov_name,
-                                                const std::vector<int32_t>& in_clusters,
+ndk::ScopedAStatus Performance::setFreqGoverner(const std::string& gov_name,
+                                                const std::vector<int32_t>& clusters,
                                                 int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": gov_name=" << in_gov_name
-              << ", clusters.size=" << in_clusters.size();
+    LOG(INFO) << __func__ << ": gov_name=" << gov_name << ", clusters.size=" << clusters.size();
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::setImFlag(const std::string& in_pid,
-                                          const std::string& in_im_flag) {
-    LOG(INFO) << __func__ << ": pid=" << in_pid << ", im_flag=" << in_im_flag;
+ndk::ScopedAStatus Performance::setImFlag(const std::string& pid, const std::string& im_flag) {
+    LOG(INFO) << __func__ << ": pid=" << pid << ", im_flag=" << im_flag;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::setProcessReclaim(const std::string& in_info,
-                                                  int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": info=" << in_info;
+ndk::ScopedAStatus Performance::setProcessReclaim(const std::string& info, int32_t* _aidl_return) {
+    LOG(INFO) << __func__ << ": info=" << info;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::setSchedAssistImptTask(const std::string& in_impt_info) {
-    LOG(INFO) << __func__ << ": impt_info=" << in_impt_info;
+ndk::ScopedAStatus Performance::setSchedAssistImptTask(const std::string& impt_info) {
+    LOG(INFO) << __func__ << ": impt_info=" << impt_info;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::setSchedAssistScene(const std::string& in_scene_id) {
-    LOG(INFO) << __func__ << ": scene_id=" << in_scene_id;
+ndk::ScopedAStatus Performance::setSchedAssistScene(const std::string& scene_id) {
+    LOG(INFO) << __func__ << ": scene_id=" << scene_id;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::setSlideboost(const std::string& in_boost) {
-    LOG(INFO) << __func__ << ": boost=" << in_boost;
+ndk::ScopedAStatus Performance::setSlideboost(const std::string& boost) {
+    LOG(INFO) << __func__ << ": boost=" << boost;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::setTpdID(const std::string& in_param, int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": param=" << in_param;
+ndk::ScopedAStatus Performance::setTpdID(const std::string& param, int32_t* _aidl_return) {
+    LOG(INFO) << __func__ << ": param=" << param;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::setTpdSerialParams(const std::string& in_params,
+ndk::ScopedAStatus Performance::setTpdSerialParams(const std::string& params,
                                                    int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": params=" << in_params;
+    LOG(INFO) << __func__ << ": params=" << params;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::setWakeSeedThread(const std::string& in_tid, bool in_identify_type,
-                                                  bool in_inUid, int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": tid=" << in_tid << ", identify_type=" << in_identify_type
-              << ", inUid=" << in_inUid;
+ndk::ScopedAStatus Performance::setWakeSeedThread(const std::string& tid, bool identify_type,
+                                                  bool inUid, int32_t* _aidl_return) {
+    LOG(INFO) << __func__ << ": tid=" << tid << ", identify_type=" << identify_type
+              << ", inUid=" << inUid;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeClmEnable(const std::string& in_buffer) {
-    LOG(INFO) << __func__ << ": buffer=" << in_buffer;
+ndk::ScopedAStatus Performance::writeClmEnable(const std::string& buffer) {
+    LOG(INFO) << __func__ << ": buffer=" << buffer;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeClmHighLoadAll(const std::string& in_buffer) {
-    LOG(INFO) << __func__ << ": buffer=" << in_buffer;
+ndk::ScopedAStatus Performance::writeClmHighLoadAll(const std::string& buffer) {
+    LOG(INFO) << __func__ << ": buffer=" << buffer;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeClmHighLoadGrp(const std::string& in_buffer) {
-    LOG(INFO) << __func__ << ": buffer=" << in_buffer;
+ndk::ScopedAStatus Performance::writeClmHighLoadGrp(const std::string& buffer) {
+    LOG(INFO) << __func__ << ": buffer=" << buffer;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeClmLowLoadGrp(const std::string& in_buffer) {
-    LOG(INFO) << __func__ << ": buffer=" << in_buffer;
+ndk::ScopedAStatus Performance::writeClmLowLoadGrp(const std::string& buffer) {
+    LOG(INFO) << __func__ << ": buffer=" << buffer;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeDBacktrace(const std::string& in_buffer) {
-    LOG(INFO) << __func__ << ": buffer=" << in_buffer;
+ndk::ScopedAStatus Performance::writeDBacktrace(const std::string& buffer) {
+    LOG(INFO) << __func__ << ": buffer=" << buffer;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeFgFreqsThreshold(const std::string& in_buffer) {
-    LOG(INFO) << __func__ << ": buffer=" << in_buffer;
+ndk::ScopedAStatus Performance::writeFgFreqsThreshold(const std::string& buffer) {
+    LOG(INFO) << __func__ << ": buffer=" << buffer;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeIOBacktrace(const std::string& in_buffer) {
-    LOG(INFO) << __func__ << ": buffer=" << in_buffer;
+ndk::ScopedAStatus Performance::writeIOBacktrace(const std::string& buffer) {
+    LOG(INFO) << __func__ << ": buffer=" << buffer;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeJankTaskTrackEnable(bool in_enable) {
-    LOG(INFO) << __func__ << ": enable=" << in_enable;
+ndk::ScopedAStatus Performance::writeJankTaskTrackEnable(bool enable) {
+    LOG(INFO) << __func__ << ": enable=" << enable;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeKmallocDebugCreate(int32_t in_kcreate, int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": kcreate=" << in_kcreate;
+ndk::ScopedAStatus Performance::writeKmallocDebugCreate(int32_t kcreate, int32_t* _aidl_return) {
+    LOG(INFO) << __func__ << ": kcreate=" << kcreate;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeKmallocDebugCreateWithType(const std::string& in_type,
+ndk::ScopedAStatus Performance::writeKmallocDebugCreateWithType(const std::string& type,
                                                                 int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": type=" << in_type;
+    LOG(INFO) << __func__ << ": type=" << type;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeMemMonitor(const std::string& in_buffer,
-                                                int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": buffer=" << in_buffer;
+ndk::ScopedAStatus Performance::writeMemMonitor(const std::string& buffer, int32_t* _aidl_return) {
+    LOG(INFO) << __func__ << ": buffer=" << buffer;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeMemleakDetectThread(int32_t in_memdect,
-                                                         int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": memdect=" << in_memdect;
+ndk::ScopedAStatus Performance::writeMemleakDetectThread(int32_t memdect, int32_t* _aidl_return) {
+    LOG(INFO) << __func__ << ": memdect=" << memdect;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeMonitorStatus(const std::string& in_buffer,
+ndk::ScopedAStatus Performance::writeMonitorStatus(const std::string& buffer,
                                                    int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": buffer=" << in_buffer;
+    LOG(INFO) << __func__ << ": buffer=" << buffer;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeNandswapProc(const std::string& in_inProc,
-                                                  const std::string& in_cmd,
+ndk::ScopedAStatus Performance::writeNandswapProc(const std::string& inProc, const std::string& cmd,
                                                   int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": inProc=" << in_inProc << ", cmd=" << in_cmd;
+    LOG(INFO) << __func__ << ": inProc=" << inProc << ", cmd=" << cmd;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeOplusReserve3(int32_t in_offset, int32_t in_len,
-                                                   const std::string& in_info,
-                                                   int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": offset=" << in_offset << ", len=" << in_len << ", info=" << in_info;
+ndk::ScopedAStatus Performance::writeOplusReserve3(int32_t offset, int32_t len,
+                                                   const std::string& info, int32_t* _aidl_return) {
+    LOG(INFO) << __func__ << ": offset=" << offset << ", len=" << len << ", info=" << info;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writePidsSet(const std::string& in_buffer) {
-    LOG(INFO) << __func__ << ": buffer=" << in_buffer;
+ndk::ScopedAStatus Performance::writePidsSet(const std::string& buffer) {
+    LOG(INFO) << __func__ << ": buffer=" << buffer;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeSchedInfoThreshold(const std::string& in_buffer) {
-    LOG(INFO) << __func__ << ": buffer=" << in_buffer;
+ndk::ScopedAStatus Performance::writeSchedInfoThreshold(const std::string& buffer) {
+    LOG(INFO) << __func__ << ": buffer=" << buffer;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeStorageFeature(const std::string& in_name,
-                                                    const std::string& in_addr,
-                                                    const std::string& in_isMulti,
-                                                    const std::string& in_cmd,
-                                                    int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": name=" << in_name << ", addr=" << in_addr
-              << ", isMulti=" << in_isMulti << ", cmd=" << in_cmd;
+ndk::ScopedAStatus Performance::writeStorageFeature(const std::string& name,
+                                                    const std::string& addr,
+                                                    const std::string& isMulti,
+                                                    const std::string& cmd, int32_t* _aidl_return) {
+    LOG(INFO) << __func__ << ": name=" << name << ", addr=" << addr << ", isMulti=" << isMulti
+              << ", cmd=" << cmd;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeTaskSchedInfo(const std::string& in_buffer) {
-    LOG(INFO) << __func__ << ": buffer=" << in_buffer;
+ndk::ScopedAStatus Performance::writeTaskSchedInfo(const std::string& buffer) {
+    LOG(INFO) << __func__ << ": buffer=" << buffer;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeTidsSet(const std::string& in_buffer) {
-    LOG(INFO) << __func__ << ": buffer=" << in_buffer;
+ndk::ScopedAStatus Performance::writeTidsSet(const std::string& buffer) {
+    LOG(INFO) << __func__ << ": buffer=" << buffer;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeTmemoryCapacity(int32_t in_param, int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": param=" << in_param;
+ndk::ScopedAStatus Performance::writeTmemoryCapacity(int32_t param, int32_t* _aidl_return) {
+    LOG(INFO) << __func__ << ": param=" << param;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeTmemoryFlushBusy(int32_t in_param, int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": param=" << in_param;
+ndk::ScopedAStatus Performance::writeTmemoryFlushBusy(int32_t param, int32_t* _aidl_return) {
+    LOG(INFO) << __func__ << ": param=" << param;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeTmemoryFlushIdle(int32_t in_param, int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": param=" << in_param;
+ndk::ScopedAStatus Performance::writeTmemoryFlushIdle(int32_t param, int32_t* _aidl_return) {
+    LOG(INFO) << __func__ << ": param=" << param;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeTmemoryHighWaterRatio(int32_t in_param,
-                                                           int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": param=" << in_param;
+ndk::ScopedAStatus Performance::writeTmemoryHighWaterRatio(int32_t param, int32_t* _aidl_return) {
+    LOG(INFO) << __func__ << ": param=" << param;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeTmemoryMemory(const std::string& in_str,
-                                                   int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": str=" << in_str;
+ndk::ScopedAStatus Performance::writeTmemoryMemory(const std::string& str, int32_t* _aidl_return) {
+    LOG(INFO) << __func__ << ": str=" << str;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeTmemorySwitch(int32_t in_param, int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": param=" << in_param;
+ndk::ScopedAStatus Performance::writeTmemorySwitch(int32_t param, int32_t* _aidl_return) {
+    LOG(INFO) << __func__ << ": param=" << param;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeUxState(const std::string& in_ux_state,
-                                             const std::string& in_pid, const std::string& in_tid,
-                                             int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": ux_state=" << in_ux_state << ", pid=" << in_pid
-              << ", tid=" << in_tid;
+ndk::ScopedAStatus Performance::writeUxState(const std::string& ux_state, const std::string& pid,
+                                             const std::string& tid, int32_t* _aidl_return) {
+    LOG(INFO) << __func__ << ": ux_state=" << ux_state << ", pid=" << pid << ", tid=" << tid;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus Performance::writeVaFeature(int32_t in_vafeature, int32_t* _aidl_return) {
-    LOG(INFO) << __func__ << ": vafeature=" << in_vafeature;
+ndk::ScopedAStatus Performance::writeVaFeature(int32_t vafeature, int32_t* _aidl_return) {
+    LOG(INFO) << __func__ << ": vafeature=" << vafeature;
     *_aidl_return = 0;
     return ndk::ScopedAStatus::ok();
 }
diff --git a/aidl/performance/Performance.h b/aidl/performance/Performance.h
index bc514db..55e6df1 100644
--- a/aidl/performance/Performance.h
+++ b/aidl/performance/Performance.h
@@ -14,19 +14,19 @@ namespace hardware {
 namespace performance {
 
 class Performance : public BnPerformance {
-    ndk::ScopedAStatus addAcmDirName(const std::string& in_dirname, int64_t in_flag,
+    ndk::ScopedAStatus addAcmDirName(const std::string& dirname, int64_t flag,
                                      int32_t* _aidl_return) override;
-    ndk::ScopedAStatus addAcmNomediaDirName(const std::string& in_dirname,
+    ndk::ScopedAStatus addAcmNomediaDirName(const std::string& dirname,
                                             int32_t* _aidl_return) override;
-    ndk::ScopedAStatus addAcmPkgName(const std::string& in_pkgname, int64_t in_flag,
+    ndk::ScopedAStatus addAcmPkgName(const std::string& pkgname, int64_t flag,
                                      int32_t* _aidl_return) override;
-    ndk::ScopedAStatus addTaskTrackPid(int32_t in_group, int32_t in_pid, bool in_clear,
+    ndk::ScopedAStatus addTaskTrackPid(int32_t group, int32_t pid, bool clear,
                                        int32_t* _aidl_return) override;
-    ndk::ScopedAStatus clearTaskTrackGroup(int32_t in_group) override;
-    ndk::ScopedAStatus delAcmDirName(const std::string& in_dirname, int32_t* _aidl_return) override;
-    ndk::ScopedAStatus delAcmNomediaDirName(const std::string& in_dirname,
+    ndk::ScopedAStatus clearTaskTrackGroup(int32_t group) override;
+    ndk::ScopedAStatus delAcmDirName(const std::string& dirname, int32_t* _aidl_return) override;
+    ndk::ScopedAStatus delAcmNomediaDirName(const std::string& dirname,
                                             int32_t* _aidl_return) override;
-    ndk::ScopedAStatus delAcmPkgName(const std::string& in_pkgname, int32_t* _aidl_return) override;
+    ndk::ScopedAStatus delAcmPkgName(const std::string& pkgname, int32_t* _aidl_return) override;
     ndk::ScopedAStatus disableDamonReclaim(int32_t* _aidl_return) override;
     ndk::ScopedAStatus disableKmallocDebug(int32_t* _aidl_return) override;
     ndk::ScopedAStatus disableMultiThreadOptimize(int32_t* _aidl_return) override;
@@ -34,7 +34,7 @@ class Performance : public BnPerformance {
     ndk::ScopedAStatus disableTaskCpustats(int32_t* _aidl_return) override;
     ndk::ScopedAStatus disableTaskPlacementDecision(int32_t* _aidl_return) override;
     ndk::ScopedAStatus disableVmallocDebug(int32_t* _aidl_return) override;
-    ndk::ScopedAStatus enableAudioPerf(const std::string& in_value, int32_t* _aidl_return) override;
+    ndk::ScopedAStatus enableAudioPerf(const std::string& value, int32_t* _aidl_return) override;
     ndk::ScopedAStatus enableDamonReclaim(int32_t* _aidl_return) override;
     ndk::ScopedAStatus enableKmallocDebug(int32_t* _aidl_return) override;
     ndk::ScopedAStatus enableMultiThreadOptimize(int32_t* _aidl_return) override;
@@ -43,18 +43,18 @@ class Performance : public BnPerformance {
     ndk::ScopedAStatus enableTaskPlacementDecision(int32_t* _aidl_return) override;
     ndk::ScopedAStatus enableVmallocDebug(int32_t* _aidl_return) override;
     ndk::ScopedAStatus existMemMonitor(int32_t* _aidl_return) override;
-    ndk::ScopedAStatus getAcmDirFlag(const std::string& in_dirname, int64_t* _aidl_return) override;
+    ndk::ScopedAStatus getAcmDirFlag(const std::string& dirname, int64_t* _aidl_return) override;
     ndk::ScopedAStatus getAcmOpstat(int32_t* _aidl_return) override;
-    ndk::ScopedAStatus getAcmPkgFlag(const std::string& in_pkgname, int64_t* _aidl_return) override;
+    ndk::ScopedAStatus getAcmPkgFlag(const std::string& pkgname, int64_t* _aidl_return) override;
     ndk::ScopedAStatus getClmMuxSwitch(std::string* _aidl_return) override;
-    ndk::ScopedAStatus getClmThreshold(int32_t in_threshold_id, std::string* _aidl_return) override;
+    ndk::ScopedAStatus getClmThreshold(int32_t threshold_id, std::string* _aidl_return) override;
     ndk::ScopedAStatus getDdrResidency(std::string* _aidl_return) override;
     ndk::ScopedAStatus getDevinfoDDRInfo(std::string* _aidl_return) override;
     ndk::ScopedAStatus getDevinfoUfsInfo(std::string* _aidl_return) override;
     ndk::ScopedAStatus getDevinfoUfsVersionInfo(std::string* _aidl_return) override;
-    ndk::ScopedAStatus getExt4FragScore(const std::string& in_devpath,
+    ndk::ScopedAStatus getExt4FragScore(const std::string& devpath,
                                         std::string* _aidl_return) override;
-    ndk::ScopedAStatus getExt4FreefragInfo(const std::string& in_devpath,
+    ndk::ScopedAStatus getExt4FreefragInfo(const std::string& devpath,
                                            std::string* _aidl_return) override;
     ndk::ScopedAStatus getF2fsMovedBlks(std::string* _aidl_return) override;
     ndk::ScopedAStatus getHIAllocWait(ProcReqHal* _aidl_return) override;
@@ -82,7 +82,7 @@ class Performance : public BnPerformance {
     ndk::ScopedAStatus getVmallocDebug(std::string* _aidl_return) override;
     ndk::ScopedAStatus getVmallocHashCal(std::string* _aidl_return) override;
     ndk::ScopedAStatus getVmallocUsed(std::string* _aidl_return) override;
-    ndk::ScopedAStatus getWakeThreadsAffinityOrdered(const std::string& in_handle, int32_t in_size,
+    ndk::ScopedAStatus getWakeThreadsAffinityOrdered(const std::string& handle, int32_t size,
                                                      TaskWakeInfo* _aidl_return) override;
     ndk::ScopedAStatus getallocwait(std::string* _aidl_return) override;
     ndk::ScopedAStatus getdstate(std::string* _aidl_return) override;
@@ -90,19 +90,19 @@ class Performance : public BnPerformance {
     ndk::ScopedAStatus getionwait(std::string* _aidl_return) override;
     ndk::ScopedAStatus getiowait(std::string* _aidl_return) override;
     ndk::ScopedAStatus getschedlatency(std::string* _aidl_return) override;
-    ndk::ScopedAStatus hybridswap_memcg_para_read(int32_t in_action, const std::string& in_cgroup,
+    ndk::ScopedAStatus hybridswap_memcg_para_read(int32_t action, const std::string& cgroup,
                                                   std::string* _aidl_return) override;
-    ndk::ScopedAStatus hybridswap_memcg_para_write(int32_t in_action, const std::string& in_cgroup,
-                                                   const std::string& in_str,
+    ndk::ScopedAStatus hybridswap_memcg_para_write(int32_t action, const std::string& cgroup,
+                                                   const std::string& str,
                                                    int32_t* _aidl_return) override;
-    ndk::ScopedAStatus hybridswap_zram_para_read(int32_t in_action,
+    ndk::ScopedAStatus hybridswap_zram_para_read(int32_t action,
                                                  std::string* _aidl_return) override;
-    ndk::ScopedAStatus hybridswap_zram_para_write(int32_t in_action, const std::string& in_str,
+    ndk::ScopedAStatus hybridswap_zram_para_write(int32_t action, const std::string& str,
                                                   int32_t* _aidl_return) override;
     ndk::ScopedAStatus isJankTaskTrackEnable(bool* _aidl_return) override;
-    ndk::ScopedAStatus perProcessMemReadahead(int32_t in_uid, int32_t in_pid, int32_t in_type,
+    ndk::ScopedAStatus perProcessMemReadahead(int32_t uid, int32_t pid, int32_t type,
                                               int32_t* _aidl_return) override;
-    ndk::ScopedAStatus perProcessMemReclaim(int32_t in_uid, int32_t in_pid, int32_t in_type,
+    ndk::ScopedAStatus perProcessMemReclaim(int32_t uid, int32_t pid, int32_t type,
                                             int32_t* _aidl_return) override;
     ndk::ScopedAStatus readCallStack(std::string* _aidl_return) override;
     ndk::ScopedAStatus readClmEnable(std::string* _aidl_return) override;
@@ -114,7 +114,7 @@ class Performance : public BnPerformance {
     ndk::ScopedAStatus readDConvert(std::string* _aidl_return) override;
     ndk::ScopedAStatus readFgFreqsThreshold(std::string* _aidl_return) override;
     ndk::ScopedAStatus readIOBacktrace(std::string* _aidl_return) override;
-    ndk::ScopedAStatus readIomonitorInfo(const std::string& in_procname,
+    ndk::ScopedAStatus readIomonitorInfo(const std::string& procname,
                                          std::string* _aidl_return) override;
     ndk::ScopedAStatus readJankCpuIndicator(std::string* _aidl_return) override;
     ndk::ScopedAStatus readJankCpuInfo(std::string* _aidl_return) override;
@@ -123,20 +123,20 @@ class Performance : public BnPerformance {
     ndk::ScopedAStatus readJankCpuLoad32(std::string* _aidl_return) override;
     ndk::ScopedAStatus readJankCpuLoad32Scale(std::string* _aidl_return) override;
     ndk::ScopedAStatus readJankTaskTrack(std::string* _aidl_return) override;
-    ndk::ScopedAStatus readJankTaskTrackByPid(int32_t in_pid, std::string* _aidl_return) override;
+    ndk::ScopedAStatus readJankTaskTrackByPid(int32_t pid, std::string* _aidl_return) override;
     ndk::ScopedAStatus readJankVersion(std::string* _aidl_return) override;
     ndk::ScopedAStatus readKmallocDebugCreate(std::string* _aidl_return) override;
     ndk::ScopedAStatus readLimitTable(std::string* _aidl_return) override;
     ndk::ScopedAStatus readMemleakDetectThread(std::string* _aidl_return) override;
-    ndk::ScopedAStatus readMemoryByPids(const std::vector<int32_t>& in_pids, int32_t in_flags,
+    ndk::ScopedAStatus readMemoryByPids(const std::vector<int32_t>& pids, int32_t flags,
                                         ProcMemStatRet* _aidl_return) override;
-    ndk::ScopedAStatus readMemoryByUids(const std::vector<int32_t>& in_uids, int32_t in_flags,
+    ndk::ScopedAStatus readMemoryByUids(const std::vector<int32_t>& uids, int32_t flags,
                                         ProcMemStatRet* _aidl_return) override;
-    ndk::ScopedAStatus readNandswapProc(const std::string& in_inProc,
+    ndk::ScopedAStatus readNandswapProc(const std::string& inProc,
                                         std::string* _aidl_return) override;
     ndk::ScopedAStatus readNormalizeRealTime(std::string* _aidl_return) override;
     ndk::ScopedAStatus readNormalizeRunningTime(std::string* _aidl_return) override;
-    ndk::ScopedAStatus readOplusReserve3(int32_t in_offset, int32_t in_len,
+    ndk::ScopedAStatus readOplusReserve3(int32_t offset, int32_t len,
                                          std::string* _aidl_return) override;
     ndk::ScopedAStatus readOsvelteVersion(OsvelteVersionRet* _aidl_return) override;
     ndk::ScopedAStatus readPidsSet(std::string* _aidl_return) override;
@@ -145,10 +145,10 @@ class Performance : public BnPerformance {
     ndk::ScopedAStatus readSchedInfoThreshold(std::string* _aidl_return) override;
     ndk::ScopedAStatus readSgeFreqInfo(std::string* _aidl_return) override;
     ndk::ScopedAStatus readSgeInfo(std::string* _aidl_return) override;
-    ndk::ScopedAStatus readStorageFeature(const std::string& in_name, const std::string& in_addr,
-                                          const std::string& in_isMulti,
+    ndk::ScopedAStatus readStorageFeature(const std::string& name, const std::string& addr,
+                                          const std::string& isMulti,
                                           std::string* _aidl_return) override;
-    ndk::ScopedAStatus readTargetProcess(const std::string& in_buffer,
+    ndk::ScopedAStatus readTargetProcess(const std::string& buffer,
                                          std::string* _aidl_return) override;
     ndk::ScopedAStatus readTaskCpustatsEnable(std::string* _aidl_return) override;
     ndk::ScopedAStatus readTaskSchedInfo(std::string* _aidl_return) override;
@@ -157,82 +157,74 @@ class Performance : public BnPerformance {
     ndk::ScopedAStatus readTmemoryErrorStat(std::string* _aidl_return) override;
     ndk::ScopedAStatus readTmemoryIoLatency(std::string* _aidl_return) override;
     ndk::ScopedAStatus readTmemorySysdirtypages(std::string* _aidl_return) override;
-    ndk::ScopedAStatus readUxTaskTrack(int32_t in_uPid, int32_t in_rPid,
+    ndk::ScopedAStatus readUxTaskTrack(int32_t uPid, int32_t rPid,
                                        std::string* _aidl_return) override;
     ndk::ScopedAStatus readVaFeature(std::string* _aidl_return) override;
     ndk::ScopedAStatus readVersion(std::string* _aidl_return) override;
-    ndk::ScopedAStatus removeTaskTrackPid(int32_t in_group, int32_t in_pid) override;
-    ndk::ScopedAStatus searchAcmNomediaDirName(const std::string& in_dirname,
+    ndk::ScopedAStatus removeTaskTrackPid(int32_t group, int32_t pid) override;
+    ndk::ScopedAStatus searchAcmNomediaDirName(const std::string& dirname,
                                                int32_t* _aidl_return) override;
-    ndk::ScopedAStatus setAcmOpstat(int32_t in_flag, int32_t* _aidl_return) override;
-    ndk::ScopedAStatus setClmMuxSwitch(const std::string& in_buffer) override;
-    ndk::ScopedAStatus setClmThreshold(const std::string& in_buffer,
-                                       int32_t in_threshold_id) override;
-    ndk::ScopedAStatus setDamonReclaimColdTime(int32_t in_cold_time,
-                                               int32_t* _aidl_return) override;
-    ndk::ScopedAStatus setDamonReclaimMonitoring(int32_t in_sample, int32_t in_aggr,
+    ndk::ScopedAStatus setAcmOpstat(int32_t flag, int32_t* _aidl_return) override;
+    ndk::ScopedAStatus setClmMuxSwitch(const std::string& buffer) override;
+    ndk::ScopedAStatus setClmThreshold(const std::string& buffer, int32_t threshold_id) override;
+    ndk::ScopedAStatus setDamonReclaimColdTime(int32_t cold_time, int32_t* _aidl_return) override;
+    ndk::ScopedAStatus setDamonReclaimMonitoring(int32_t sample, int32_t aggr,
                                                  int32_t* _aidl_return) override;
-    ndk::ScopedAStatus setDamonReclaimQuota(int32_t in_quota_ms, int32_t in_quota_sz,
-                                            int32_t in_reset_interval,
-                                            int32_t* _aidl_return) override;
-    ndk::ScopedAStatus setDamonReclaimWmarks(int32_t in_metric, int32_t in_high, int32_t in_mid,
-                                             int32_t in_low, int32_t* _aidl_return) override;
-    ndk::ScopedAStatus setExtSchedProp(const std::string& in_pid,
-                                       const std::string& in_prop) override;
-    ndk::ScopedAStatus setFgUids(const std::string& in_fg_uid) override;
-    ndk::ScopedAStatus setFrameRate(const std::string& in_frame_rate) override;
-    ndk::ScopedAStatus setFreqGoverner(const std::string& in_gov_name,
-                                       const std::vector<int32_t>& in_clusters,
+    ndk::ScopedAStatus setDamonReclaimQuota(int32_t quota_ms, int32_t quota_sz,
+                                            int32_t reset_interval, int32_t* _aidl_return) override;
+    ndk::ScopedAStatus setDamonReclaimWmarks(int32_t metric, int32_t high, int32_t mid, int32_t low,
+                                             int32_t* _aidl_return) override;
+    ndk::ScopedAStatus setExtSchedProp(const std::string& pid, const std::string& prop) override;
+    ndk::ScopedAStatus setFgUids(const std::string& fg_uid) override;
+    ndk::ScopedAStatus setFrameRate(const std::string& frame_rate) override;
+    ndk::ScopedAStatus setFreqGoverner(const std::string& gov_name,
+                                       const std::vector<int32_t>& clusters,
                                        int32_t* _aidl_return) override;
-    ndk::ScopedAStatus setImFlag(const std::string& in_pid, const std::string& in_im_flag) override;
-    ndk::ScopedAStatus setProcessReclaim(const std::string& in_info,
-                                         int32_t* _aidl_return) override;
-    ndk::ScopedAStatus setSchedAssistImptTask(const std::string& in_impt_info) override;
-    ndk::ScopedAStatus setSchedAssistScene(const std::string& in_scene_id) override;
-    ndk::ScopedAStatus setSlideboost(const std::string& in_boost) override;
-    ndk::ScopedAStatus setTpdID(const std::string& in_param, int32_t* _aidl_return) override;
-    ndk::ScopedAStatus setTpdSerialParams(const std::string& in_params,
+    ndk::ScopedAStatus setImFlag(const std::string& pid, const std::string& im_flag) override;
+    ndk::ScopedAStatus setProcessReclaim(const std::string& info, int32_t* _aidl_return) override;
+    ndk::ScopedAStatus setSchedAssistImptTask(const std::string& impt_info) override;
+    ndk::ScopedAStatus setSchedAssistScene(const std::string& scene_id) override;
+    ndk::ScopedAStatus setSlideboost(const std::string& boost) override;
+    ndk::ScopedAStatus setTpdID(const std::string& param, int32_t* _aidl_return) override;
+    ndk::ScopedAStatus setTpdSerialParams(const std::string& params,
                                           int32_t* _aidl_return) override;
-    ndk::ScopedAStatus setWakeSeedThread(const std::string& in_tid, bool in_identify_type,
-                                         bool in_inUid, int32_t* _aidl_return) override;
-    ndk::ScopedAStatus writeClmEnable(const std::string& in_buffer) override;
-    ndk::ScopedAStatus writeClmHighLoadAll(const std::string& in_buffer) override;
-    ndk::ScopedAStatus writeClmHighLoadGrp(const std::string& in_buffer) override;
-    ndk::ScopedAStatus writeClmLowLoadGrp(const std::string& in_buffer) override;
-    ndk::ScopedAStatus writeDBacktrace(const std::string& in_buffer) override;
-    ndk::ScopedAStatus writeFgFreqsThreshold(const std::string& in_buffer) override;
-    ndk::ScopedAStatus writeIOBacktrace(const std::string& in_buffer) override;
-    ndk::ScopedAStatus writeJankTaskTrackEnable(bool in_enable) override;
-    ndk::ScopedAStatus writeKmallocDebugCreate(int32_t in_kcreate, int32_t* _aidl_return) override;
-    ndk::ScopedAStatus writeKmallocDebugCreateWithType(const std::string& in_type,
+    ndk::ScopedAStatus setWakeSeedThread(const std::string& tid, bool identify_type, bool inUid,
+                                         int32_t* _aidl_return) override;
+    ndk::ScopedAStatus writeClmEnable(const std::string& buffer) override;
+    ndk::ScopedAStatus writeClmHighLoadAll(const std::string& buffer) override;
+    ndk::ScopedAStatus writeClmHighLoadGrp(const std::string& buffer) override;
+    ndk::ScopedAStatus writeClmLowLoadGrp(const std::string& buffer) override;
+    ndk::ScopedAStatus writeDBacktrace(const std::string& buffer) override;
+    ndk::ScopedAStatus writeFgFreqsThreshold(const std::string& buffer) override;
+    ndk::ScopedAStatus writeIOBacktrace(const std::string& buffer) override;
+    ndk::ScopedAStatus writeJankTaskTrackEnable(bool enable) override;
+    ndk::ScopedAStatus writeKmallocDebugCreate(int32_t kcreate, int32_t* _aidl_return) override;
+    ndk::ScopedAStatus writeKmallocDebugCreateWithType(const std::string& type,
                                                        int32_t* _aidl_return) override;
-    ndk::ScopedAStatus writeMemMonitor(const std::string& in_buffer,
-                                       int32_t* _aidl_return) override;
-    ndk::ScopedAStatus writeMemleakDetectThread(int32_t in_memdect, int32_t* _aidl_return) override;
-    ndk::ScopedAStatus writeMonitorStatus(const std::string& in_buffer,
+    ndk::ScopedAStatus writeMemMonitor(const std::string& buffer, int32_t* _aidl_return) override;
+    ndk::ScopedAStatus writeMemleakDetectThread(int32_t memdect, int32_t* _aidl_return) override;
+    ndk::ScopedAStatus writeMonitorStatus(const std::string& buffer,
                                           int32_t* _aidl_return) override;
-    ndk::ScopedAStatus writeNandswapProc(const std::string& in_inProc, const std::string& in_cmd,
+    ndk::ScopedAStatus writeNandswapProc(const std::string& inProc, const std::string& cmd,
                                          int32_t* _aidl_return) override;
-    ndk::ScopedAStatus writeOplusReserve3(int32_t in_offset, int32_t in_len,
-                                          const std::string& in_info,
+    ndk::ScopedAStatus writeOplusReserve3(int32_t offset, int32_t len, const std::string& info,
                                           int32_t* _aidl_return) override;
-    ndk::ScopedAStatus writePidsSet(const std::string& in_buffer) override;
-    ndk::ScopedAStatus writeSchedInfoThreshold(const std::string& in_buffer) override;
-    ndk::ScopedAStatus writeStorageFeature(const std::string& in_name, const std::string& in_addr,
-                                           const std::string& in_isMulti, const std::string& in_cmd,
+    ndk::ScopedAStatus writePidsSet(const std::string& buffer) override;
+    ndk::ScopedAStatus writeSchedInfoThreshold(const std::string& buffer) override;
+    ndk::ScopedAStatus writeStorageFeature(const std::string& name, const std::string& addr,
+                                           const std::string& isMulti, const std::string& cmd,
                                            int32_t* _aidl_return) override;
-    ndk::ScopedAStatus writeTaskSchedInfo(const std::string& in_buffer) override;
-    ndk::ScopedAStatus writeTidsSet(const std::string& in_buffer) override;
-    ndk::ScopedAStatus writeTmemoryCapacity(int32_t in_param, int32_t* _aidl_return) override;
-    ndk::ScopedAStatus writeTmemoryFlushBusy(int32_t in_param, int32_t* _aidl_return) override;
-    ndk::ScopedAStatus writeTmemoryFlushIdle(int32_t in_param, int32_t* _aidl_return) override;
-    ndk::ScopedAStatus writeTmemoryHighWaterRatio(int32_t in_param, int32_t* _aidl_return) override;
-    ndk::ScopedAStatus writeTmemoryMemory(const std::string& in_str,
-                                          int32_t* _aidl_return) override;
-    ndk::ScopedAStatus writeTmemorySwitch(int32_t in_param, int32_t* _aidl_return) override;
-    ndk::ScopedAStatus writeUxState(const std::string& in_ux_state, const std::string& in_pid,
-                                    const std::string& in_tid, int32_t* _aidl_return) override;
-    ndk::ScopedAStatus writeVaFeature(int32_t in_vafeature, int32_t* _aidl_return) override;
+    ndk::ScopedAStatus writeTaskSchedInfo(const std::string& buffer) override;
+    ndk::ScopedAStatus writeTidsSet(const std::string& buffer) override;
+    ndk::ScopedAStatus writeTmemoryCapacity(int32_t param, int32_t* _aidl_return) override;
+    ndk::ScopedAStatus writeTmemoryFlushBusy(int32_t param, int32_t* _aidl_return) override;
+    ndk::ScopedAStatus writeTmemoryFlushIdle(int32_t param, int32_t* _aidl_return) override;
+    ndk::ScopedAStatus writeTmemoryHighWaterRatio(int32_t param, int32_t* _aidl_return) override;
+    ndk::ScopedAStatus writeTmemoryMemory(const std::string& str, int32_t* _aidl_return) override;
+    ndk::ScopedAStatus writeTmemorySwitch(int32_t param, int32_t* _aidl_return) override;
+    ndk::ScopedAStatus writeUxState(const std::string& ux_state, const std::string& pid,
+                                    const std::string& tid, int32_t* _aidl_return) override;
+    ndk::ScopedAStatus writeVaFeature(int32_t vafeature, int32_t* _aidl_return) override;
 };
 
 }  // namespace performance
diff --git a/nrmodeswitcher/OplusRadioResponse.cpp b/nrmodeswitcher/OplusRadioResponse.cpp
index 3884082..692bdf1 100644
--- a/nrmodeswitcher/OplusRadioResponse.cpp
+++ b/nrmodeswitcher/OplusRadioResponse.cpp
@@ -7,199 +7,197 @@
 
 namespace aidl::vendor::oplus::hardware::radio {
 
-OplusRadioResponse::OplusRadioResponse(int32_t& in_result) : in_result_(in_result) {}
+OplusRadioResponse::OplusRadioResponse(int32_t& result) : result_(result) {}
 
 ndk::ScopedAStatus OplusRadioResponse::setCallbackExtResponse() {
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus OplusRadioResponse::setNrModeResponse(const OplusRadioResponseInfo& in_info,
-                                                         int32_t in_result) {
-    in_result_ = in_result;
+ndk::ScopedAStatus OplusRadioResponse::setNrModeResponse(const OplusRadioResponseInfo& info,
+                                                         int32_t result) {
+    result_ = result;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus OplusRadioResponse::getNrModeResponse(const OplusRadioResponseInfo& in_info,
-                                                         int32_t in_result) {
+ndk::ScopedAStatus OplusRadioResponse::getNrModeResponse(const OplusRadioResponseInfo& info,
+                                                         int32_t result) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::setModemErrorFatalResponse(
-        const OplusRadioResponseInfo& in_info) {
+        const OplusRadioResponseInfo& info) {
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus OplusRadioResponse::setVoNrEnabledResponse(
-        const OplusRadioResponseInfo& in_info) {
+ndk::ScopedAStatus OplusRadioResponse::setVoNrEnabledResponse(const OplusRadioResponseInfo& info) {
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus OplusRadioResponse::getVoNrEnabledResponse(const OplusRadioResponseInfo& in_info,
-                                                              bool in_result) {
+ndk::ScopedAStatus OplusRadioResponse::getVoNrEnabledResponse(const OplusRadioResponseInfo& info,
+                                                              bool result) {
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus OplusRadioResponse::setEccListResponse(const OplusRadioResponseInfo& in_info,
-                                                          const std::string& in_result) {
+ndk::ScopedAStatus OplusRadioResponse::setEccListResponse(const OplusRadioResponseInfo& info,
+                                                          const std::string& result) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::SetHsrModeForListeningResponse(
-        const OplusRadioResponseInfo& in_info, int32_t in_result) {
+        const OplusRadioResponseInfo& info, int32_t result) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::SetLogIdForListeningResponse(
-        const OplusRadioResponseInfo& in_info, int32_t in_result) {
+        const OplusRadioResponseInfo& info, int32_t result) {
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus OplusRadioResponse::setSlowStartResponse(const OplusRadioResponseInfo& in_info) {
+ndk::ScopedAStatus OplusRadioResponse::setSlowStartResponse(const OplusRadioResponseInfo& info) {
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus OplusRadioResponse::setCtVolteModeResponse(
-        const OplusRadioResponseInfo& in_info) {
+ndk::ScopedAStatus OplusRadioResponse::setCtVolteModeResponse(const OplusRadioResponseInfo& info) {
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus OplusRadioResponse::simlockReqResponse(const OplusRadioResponseInfo& in_info,
-                                                          const std::vector<uint8_t>& in_result) {
+ndk::ScopedAStatus OplusRadioResponse::simlockReqResponse(const OplusRadioResponseInfo& info,
+                                                          const std::vector<uint8_t>& result) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::updateRegionlockBlobResponse(
-        const OplusRadioResponseInfo& in_info, const std::vector<uint8_t>& in_status) {
+        const OplusRadioResponseInfo& info, const std::vector<uint8_t>& status) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::updateRegionlockStatusResponse(
-        const OplusRadioResponseInfo& in_info, const std::vector<uint8_t>& in_status) {
+        const OplusRadioResponseInfo& info, const std::vector<uint8_t>& status) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::getRegionlockStatusResponse(
-        const OplusRadioResponseInfo& in_info, const std::vector<uint8_t>& in_status) {
+        const OplusRadioResponseInfo& info, const std::vector<uint8_t>& status) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::setNwCongestionCfgResponse(
-        const OplusRadioResponseInfo& in_info, const std::vector<uint8_t>& in_status) {
+        const OplusRadioResponseInfo& info, const std::vector<uint8_t>& status) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::setModemEsimStatusResponse(
-        const OplusRadioResponseInfo& in_info) {
+        const OplusRadioResponseInfo& info) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::getSimlockOperatorIdResponse(
-        const OplusRadioResponseInfo& in_info, int32_t in_result) {
+        const OplusRadioResponseInfo& info, int32_t result) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::getSimlockFeestateResponse(
-        const OplusRadioResponseInfo& in_info, int32_t in_result) {
+        const OplusRadioResponseInfo& info, int32_t result) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::setSimlockFeestateResponse(
-        const OplusRadioResponseInfo& in_info) {
+        const OplusRadioResponseInfo& info) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::getSimlockUnlockStateResponse(
-        const OplusRadioResponseInfo& in_info, int32_t in_result) {
+        const OplusRadioResponseInfo& info, int32_t result) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::setSimlockFactoryResetTimeResponse(
-        const OplusRadioResponseInfo& in_info) {
+        const OplusRadioResponseInfo& info) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::getSimlockFactoryResetTimeResponse(
-        const OplusRadioResponseInfo& in_info, const std::vector<uint8_t>& in_status) {
+        const OplusRadioResponseInfo& info, const std::vector<uint8_t>& status) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::setSimlockActivateTimeResponse(
-        const OplusRadioResponseInfo& in_info) {
+        const OplusRadioResponseInfo& info) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::getSimlockActivateTimeResponse(
-        const OplusRadioResponseInfo& in_info, const std::vector<uint8_t>& in_status) {
+        const OplusRadioResponseInfo& info, const std::vector<uint8_t>& status) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::getSimlockFeatureResponse(
-        const OplusRadioResponseInfo& in_info, const std::vector<uint8_t>& in_feature) {
+        const OplusRadioResponseInfo& info, const std::vector<uint8_t>& feature) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::getSimlockLockMarkResponse(
-        const OplusRadioResponseInfo& in_info, const std::vector<uint8_t>& in_lockmark) {
+        const OplusRadioResponseInfo& info, const std::vector<uint8_t>& lockmark) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::getSimlockDeviceLockStateResponse(
-        const OplusRadioResponseInfo& in_info, int32_t in_lockstate) {
+        const OplusRadioResponseInfo& info, int32_t lockstate) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::getSimlockDeviceLockinfoResponse(
-        const OplusRadioResponseInfo& in_info, const std::vector<uint8_t>& in_lockinfo) {
+        const OplusRadioResponseInfo& info, const std::vector<uint8_t>& lockinfo) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::getSimlockVersionInfoResponse(
-        const OplusRadioResponseInfo& in_info, const std::vector<uint8_t>& in_version) {
+        const OplusRadioResponseInfo& info, const std::vector<uint8_t>& version) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::getSimlockMaxRetryResponse(
-        const OplusRadioResponseInfo& in_info, int32_t in_result) {
+        const OplusRadioResponseInfo& info, int32_t result) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::getSimlockCurrentRetryResponse(
-        const OplusRadioResponseInfo& in_info, int32_t in_result) {
+        const OplusRadioResponseInfo& info, int32_t result) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::setPsDetachAttachActionResponse(
-        const OplusRadioResponseInfo& in_info) {
+        const OplusRadioResponseInfo& info) {
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus OplusRadioResponse::unlockRegionlockResponse(
-        const OplusRadioResponseInfo& in_info, int32_t in_result) {
+ndk::ScopedAStatus OplusRadioResponse::unlockRegionlockResponse(const OplusRadioResponseInfo& info,
+                                                                int32_t result) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::updateRegionlockKeyResponse(
-        const OplusRadioResponseInfo& in_info, int32_t in_result) {
+        const OplusRadioResponseInfo& info, int32_t result) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::getRegionlockSettingDataResponse(
-        const OplusRadioResponseInfo& in_info, const std::vector<uint8_t>& in_result) {
+        const OplusRadioResponseInfo& info, const std::vector<uint8_t>& result) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::setRegionlockSettingDataResponse(
-        const OplusRadioResponseInfo& in_info, int32_t in_result) {
+        const OplusRadioResponseInfo& info, int32_t result) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::setSimlockOfflineLockResponse(
-        const OplusRadioResponseInfo& in_info) {
+        const OplusRadioResponseInfo& info) {
     return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus OplusRadioResponse::getSimlockOfflineLockResponse(
-        const OplusRadioResponseInfo& in_info, const std::vector<int32_t>& in_retryCount) {
+        const OplusRadioResponseInfo& info, const std::vector<int32_t>& retryCount) {
     return ndk::ScopedAStatus::ok();
 }
 
diff --git a/nrmodeswitcher/OplusRadioResponse.h b/nrmodeswitcher/OplusRadioResponse.h
index ab305d8..0c72e25 100644
--- a/nrmodeswitcher/OplusRadioResponse.h
+++ b/nrmodeswitcher/OplusRadioResponse.h
@@ -11,83 +11,78 @@ namespace aidl::vendor::oplus::hardware::radio {
 
 class OplusRadioResponse : public BnOplusRadioResponse {
   public:
-    explicit OplusRadioResponse(int32_t& in_result);
+    explicit OplusRadioResponse(int32_t& result);
     ndk::ScopedAStatus setCallbackExtResponse() override;
-    ndk::ScopedAStatus setNrModeResponse(const OplusRadioResponseInfo& in_info,
-                                         int32_t in_result) override;
-    ndk::ScopedAStatus getNrModeResponse(const OplusRadioResponseInfo& in_info,
-                                         int32_t in_result) override;
-    ndk::ScopedAStatus setModemErrorFatalResponse(const OplusRadioResponseInfo& in_info) override;
-    ndk::ScopedAStatus setVoNrEnabledResponse(const OplusRadioResponseInfo& in_info) override;
-    ndk::ScopedAStatus getVoNrEnabledResponse(const OplusRadioResponseInfo& in_info,
-                                              bool in_result) override;
-    ndk::ScopedAStatus setEccListResponse(const OplusRadioResponseInfo& in_info,
-                                          const std::string& in_result) override;
-    ndk::ScopedAStatus SetHsrModeForListeningResponse(const OplusRadioResponseInfo& in_info,
-                                                      int32_t in_result) override;
-    ndk::ScopedAStatus SetLogIdForListeningResponse(const OplusRadioResponseInfo& in_info,
-                                                    int32_t in_result) override;
-    ndk::ScopedAStatus setSlowStartResponse(const OplusRadioResponseInfo& in_info) override;
-    ndk::ScopedAStatus setCtVolteModeResponse(const OplusRadioResponseInfo& in_info) override;
-    ndk::ScopedAStatus simlockReqResponse(const OplusRadioResponseInfo& in_info,
-                                          const std::vector<uint8_t>& in_result) override;
-    ndk::ScopedAStatus updateRegionlockBlobResponse(const OplusRadioResponseInfo& in_info,
-                                                    const std::vector<uint8_t>& in_status) override;
-    ndk::ScopedAStatus updateRegionlockStatusResponse(
-            const OplusRadioResponseInfo& in_info, const std::vector<uint8_t>& in_status) override;
-    ndk::ScopedAStatus getRegionlockStatusResponse(const OplusRadioResponseInfo& in_info,
-                                                   const std::vector<uint8_t>& in_status) override;
-    ndk::ScopedAStatus setNwCongestionCfgResponse(const OplusRadioResponseInfo& in_info,
-                                                  const std::vector<uint8_t>& in_status) override;
-    ndk::ScopedAStatus setModemEsimStatusResponse(const OplusRadioResponseInfo& in_info) override;
-    ndk::ScopedAStatus getSimlockOperatorIdResponse(const OplusRadioResponseInfo& in_info,
-                                                    int32_t in_result) override;
-    ndk::ScopedAStatus getSimlockFeestateResponse(const OplusRadioResponseInfo& in_info,
-                                                  int32_t in_result) override;
-    ndk::ScopedAStatus setSimlockFeestateResponse(const OplusRadioResponseInfo& in_info) override;
-    ndk::ScopedAStatus getSimlockUnlockStateResponse(const OplusRadioResponseInfo& in_info,
-                                                     int32_t in_result) override;
+    ndk::ScopedAStatus setNrModeResponse(const OplusRadioResponseInfo& info,
+                                         int32_t result) override;
+    ndk::ScopedAStatus getNrModeResponse(const OplusRadioResponseInfo& info,
+                                         int32_t result) override;
+    ndk::ScopedAStatus setModemErrorFatalResponse(const OplusRadioResponseInfo& info) override;
+    ndk::ScopedAStatus setVoNrEnabledResponse(const OplusRadioResponseInfo& info) override;
+    ndk::ScopedAStatus getVoNrEnabledResponse(const OplusRadioResponseInfo& info,
+                                              bool result) override;
+    ndk::ScopedAStatus setEccListResponse(const OplusRadioResponseInfo& info,
+                                          const std::string& result) override;
+    ndk::ScopedAStatus SetHsrModeForListeningResponse(const OplusRadioResponseInfo& info,
+                                                      int32_t result) override;
+    ndk::ScopedAStatus SetLogIdForListeningResponse(const OplusRadioResponseInfo& info,
+                                                    int32_t result) override;
+    ndk::ScopedAStatus setSlowStartResponse(const OplusRadioResponseInfo& info) override;
+    ndk::ScopedAStatus setCtVolteModeResponse(const OplusRadioResponseInfo& info) override;
+    ndk::ScopedAStatus simlockReqResponse(const OplusRadioResponseInfo& info,
+                                          const std::vector<uint8_t>& result) override;
+    ndk::ScopedAStatus updateRegionlockBlobResponse(const OplusRadioResponseInfo& info,
+                                                    const std::vector<uint8_t>& status) override;
+    ndk::ScopedAStatus updateRegionlockStatusResponse(const OplusRadioResponseInfo& info,
+                                                      const std::vector<uint8_t>& status) override;
+    ndk::ScopedAStatus getRegionlockStatusResponse(const OplusRadioResponseInfo& info,
+                                                   const std::vector<uint8_t>& status) override;
+    ndk::ScopedAStatus setNwCongestionCfgResponse(const OplusRadioResponseInfo& info,
+                                                  const std::vector<uint8_t>& status) override;
+    ndk::ScopedAStatus setModemEsimStatusResponse(const OplusRadioResponseInfo& info) override;
+    ndk::ScopedAStatus getSimlockOperatorIdResponse(const OplusRadioResponseInfo& info,
+                                                    int32_t result) override;
+    ndk::ScopedAStatus getSimlockFeestateResponse(const OplusRadioResponseInfo& info,
+                                                  int32_t result) override;
+    ndk::ScopedAStatus setSimlockFeestateResponse(const OplusRadioResponseInfo& info) override;
+    ndk::ScopedAStatus getSimlockUnlockStateResponse(const OplusRadioResponseInfo& info,
+                                                     int32_t result) override;
     ndk::ScopedAStatus setSimlockFactoryResetTimeResponse(
-            const OplusRadioResponseInfo& in_info) override;
+            const OplusRadioResponseInfo& info) override;
     ndk::ScopedAStatus getSimlockFactoryResetTimeResponse(
-            const OplusRadioResponseInfo& in_info, const std::vector<uint8_t>& in_status) override;
-    ndk::ScopedAStatus setSimlockActivateTimeResponse(
-            const OplusRadioResponseInfo& in_info) override;
-    ndk::ScopedAStatus getSimlockActivateTimeResponse(
-            const OplusRadioResponseInfo& in_info, const std::vector<uint8_t>& in_status) override;
-    ndk::ScopedAStatus getSimlockFeatureResponse(const OplusRadioResponseInfo& in_info,
-                                                 const std::vector<uint8_t>& in_feature) override;
-    ndk::ScopedAStatus getSimlockLockMarkResponse(const OplusRadioResponseInfo& in_info,
-                                                  const std::vector<uint8_t>& in_lockmark) override;
-    ndk::ScopedAStatus getSimlockDeviceLockStateResponse(const OplusRadioResponseInfo& in_info,
-                                                         int32_t in_lockstate) override;
+            const OplusRadioResponseInfo& info, const std::vector<uint8_t>& status) override;
+    ndk::ScopedAStatus setSimlockActivateTimeResponse(const OplusRadioResponseInfo& info) override;
+    ndk::ScopedAStatus getSimlockActivateTimeResponse(const OplusRadioResponseInfo& info,
+                                                      const std::vector<uint8_t>& status) override;
+    ndk::ScopedAStatus getSimlockFeatureResponse(const OplusRadioResponseInfo& info,
+                                                 const std::vector<uint8_t>& feature) override;
+    ndk::ScopedAStatus getSimlockLockMarkResponse(const OplusRadioResponseInfo& info,
+                                                  const std::vector<uint8_t>& lockmark) override;
+    ndk::ScopedAStatus getSimlockDeviceLockStateResponse(const OplusRadioResponseInfo& info,
+                                                         int32_t lockstate) override;
     ndk::ScopedAStatus getSimlockDeviceLockinfoResponse(
-            const OplusRadioResponseInfo& in_info,
-            const std::vector<uint8_t>& in_lockinfo) override;
-    ndk::ScopedAStatus getSimlockVersionInfoResponse(
-            const OplusRadioResponseInfo& in_info, const std::vector<uint8_t>& in_version) override;
-    ndk::ScopedAStatus getSimlockMaxRetryResponse(const OplusRadioResponseInfo& in_info,
-                                                  int32_t in_result) override;
-    ndk::ScopedAStatus getSimlockCurrentRetryResponse(const OplusRadioResponseInfo& in_info,
-                                                      int32_t in_result) override;
-    ndk::ScopedAStatus setPsDetachAttachActionResponse(
-            const OplusRadioResponseInfo& in_info) override;
-    ndk::ScopedAStatus unlockRegionlockResponse(const OplusRadioResponseInfo& in_info,
-                                                int32_t in_result) override;
-    ndk::ScopedAStatus updateRegionlockKeyResponse(const OplusRadioResponseInfo& in_info,
-                                                   int32_t in_result) override;
+            const OplusRadioResponseInfo& info, const std::vector<uint8_t>& lockinfo) override;
+    ndk::ScopedAStatus getSimlockVersionInfoResponse(const OplusRadioResponseInfo& info,
+                                                     const std::vector<uint8_t>& version) override;
+    ndk::ScopedAStatus getSimlockMaxRetryResponse(const OplusRadioResponseInfo& info,
+                                                  int32_t result) override;
+    ndk::ScopedAStatus getSimlockCurrentRetryResponse(const OplusRadioResponseInfo& info,
+                                                      int32_t result) override;
+    ndk::ScopedAStatus setPsDetachAttachActionResponse(const OplusRadioResponseInfo& info) override;
+    ndk::ScopedAStatus unlockRegionlockResponse(const OplusRadioResponseInfo& info,
+                                                int32_t result) override;
+    ndk::ScopedAStatus updateRegionlockKeyResponse(const OplusRadioResponseInfo& info,
+                                                   int32_t result) override;
     ndk::ScopedAStatus getRegionlockSettingDataResponse(
-            const OplusRadioResponseInfo& in_info, const std::vector<uint8_t>& in_result) override;
-    ndk::ScopedAStatus setRegionlockSettingDataResponse(const OplusRadioResponseInfo& in_info,
-                                                        int32_t in_result) override;
-    ndk::ScopedAStatus setSimlockOfflineLockResponse(
-            const OplusRadioResponseInfo& in_info) override;
+            const OplusRadioResponseInfo& info, const std::vector<uint8_t>& result) override;
+    ndk::ScopedAStatus setRegionlockSettingDataResponse(const OplusRadioResponseInfo& info,
+                                                        int32_t result) override;
+    ndk::ScopedAStatus setSimlockOfflineLockResponse(const OplusRadioResponseInfo& info) override;
     ndk::ScopedAStatus getSimlockOfflineLockResponse(
-            const OplusRadioResponseInfo& in_info,
-            const std::vector<int32_t>& in_retryCount) override;
+            const OplusRadioResponseInfo& info, const std::vector<int32_t>& retryCount) override;
 
   private:
-    int32_t& in_result_;
+    int32_t& result_;
 };
 
 };  // namespace aidl::vendor::oplus::hardware::radio
diff --git a/nrmodeswitcher/main.cpp b/nrmodeswitcher/main.cpp
index 0ac4681..2446517 100644
--- a/nrmodeswitcher/main.cpp
+++ b/nrmodeswitcher/main.cpp
@@ -66,14 +66,14 @@ int main() {
             continue;
         }
 
-        int32_t in_result = 0;
-        auto resp_cb = ndk::SharedRefBase::make<OplusRadioResponse>(in_result);
+        int32_t result = 0;
+        auto resp_cb = ndk::SharedRefBase::make<OplusRadioResponse>(result);
         radio->setCallback(resp_cb, nullptr);
 
         bool succeed = false;
         for (auto retry = 100; retry > 0; --retry) {
             auto status = radio->setNrMode(kOplusRilSerial, mode);
-            if (!status.isOk() || in_result != 0) {
+            if (!status.isOk() || result != 0) {
                 LOG(ERROR) << "setNrMode failed for SIM" << i
                            << ", (remaining retries: " << retry - 1 << ")";
                 std::this_thread::sleep_for(1s);