diff --git a/services/mediatranscoding/tests/MediaTranscodingServiceTestHelper.h b/services/mediatranscoding/tests/MediaTranscodingServiceTestHelper.h
index 6d0b99e..5f4f645 100644
--- a/services/mediatranscoding/tests/MediaTranscodingServiceTestHelper.h
+++ b/services/mediatranscoding/tests/MediaTranscodingServiceTestHelper.h
@@ -20,9 +20,9 @@
 #include <aidl/android/media/IMediaTranscodingService.h>
 #include <aidl/android/media/ITranscodingClient.h>
 #include <aidl/android/media/ITranscodingClientCallback.h>
-#include <aidl/android/media/TranscodingJobParcel.h>
-#include <aidl/android/media/TranscodingJobPriority.h>
 #include <aidl/android/media/TranscodingRequestParcel.h>
+#include <aidl/android/media/TranscodingSessionParcel.h>
+#include <aidl/android/media/TranscodingSessionPriority.h>
 #include <android-base/logging.h>
 #include <android/binder_manager.h>
 #include <android/binder_process.h>
@@ -48,9 +48,9 @@
 using aidl::android::media::IMediaTranscodingService;
 using aidl::android::media::ITranscodingClient;
 using aidl::android::media::ITranscodingClientCallback;
-using aidl::android::media::TranscodingJobParcel;
-using aidl::android::media::TranscodingJobPriority;
 using aidl::android::media::TranscodingRequestParcel;
+using aidl::android::media::TranscodingSessionParcel;
+using aidl::android::media::TranscodingSessionPriority;
 using aidl::android::media::TranscodingVideoTrackFormat;
 
 constexpr int32_t kClientUseCallingPid = IMediaTranscodingService::USE_CALLING_PID;
@@ -112,12 +112,12 @@
     struct Event {
         enum { NoEvent, Start, Pause, Resume, Finished, Failed } type;
         int64_t clientId;
-        int32_t jobId;
+        int32_t sessionId;
     };
 
-#define DECLARE_EVENT(action)                              \
-    static Event action(int32_t clientId, int32_t jobId) { \
-        return {Event::action, clientId, jobId};           \
+#define DECLARE_EVENT(action)                                  \
+    static Event action(int32_t clientId, int32_t sessionId) { \
+        return {Event::action, clientId, sessionId};           \
     }
 
     DECLARE_EVENT(Start);
@@ -149,8 +149,8 @@
         default:
             return "NoEvent";
         }
-        return "job {" + std::to_string(event.clientId) + ", " + std::to_string(event.jobId) +
-               "}: " + eventStr;
+        return "session {" + std::to_string(event.clientId) + ", " +
+               std::to_string(event.sessionId) + "}: " + eventStr;
     }
 
     // Pop 1 event from front, wait for up to timeoutUs if empty.
@@ -238,7 +238,7 @@
 
 // Operators for GTest macros.
 bool operator==(const EventTracker::Event& lhs, const EventTracker::Event& rhs) {
-    return lhs.type == rhs.type && lhs.clientId == rhs.clientId && lhs.jobId == rhs.jobId;
+    return lhs.type == rhs.type && lhs.clientId == rhs.clientId && lhs.sessionId == rhs.sessionId;
 }
 
 std::ostream& operator<<(std::ostream& str, const EventTracker::Event& v) {
@@ -288,40 +288,41 @@
         return Status::ok();
     }
 
-    Status onTranscodingStarted(int32_t in_jobId) override {
-        append(EventTracker::Start(mClientId, in_jobId));
+    Status onTranscodingStarted(int32_t in_sessionId) override {
+        append(EventTracker::Start(mClientId, in_sessionId));
         return Status::ok();
     }
 
-    Status onTranscodingPaused(int32_t in_jobId) override {
-        append(EventTracker::Pause(mClientId, in_jobId));
+    Status onTranscodingPaused(int32_t in_sessionId) override {
+        append(EventTracker::Pause(mClientId, in_sessionId));
         return Status::ok();
     }
 
-    Status onTranscodingResumed(int32_t in_jobId) override {
-        append(EventTracker::Resume(mClientId, in_jobId));
+    Status onTranscodingResumed(int32_t in_sessionId) override {
+        append(EventTracker::Resume(mClientId, in_sessionId));
         return Status::ok();
     }
 
     Status onTranscodingFinished(
-            int32_t in_jobId,
+            int32_t in_sessionId,
             const ::aidl::android::media::TranscodingResultParcel& /* in_result */) override {
-        append(Finished(mClientId, in_jobId));
+        append(Finished(mClientId, in_sessionId));
         return Status::ok();
     }
 
-    Status onTranscodingFailed(int32_t in_jobId,
+    Status onTranscodingFailed(int32_t in_sessionId,
                                ::aidl::android::media::TranscodingErrorCode in_errorCode) override {
-        append(Failed(mClientId, in_jobId), in_errorCode);
+        append(Failed(mClientId, in_sessionId), in_errorCode);
         return Status::ok();
     }
 
-    Status onAwaitNumberOfJobsChanged(int32_t /* in_jobId */, int32_t /* in_oldAwaitNumber */,
-                                      int32_t /* in_newAwaitNumber */) override {
+    Status onAwaitNumberOfSessionsChanged(int32_t /* in_sessionId */,
+                                          int32_t /* in_oldAwaitNumber */,
+                                          int32_t /* in_newAwaitNumber */) override {
         return Status::ok();
     }
 
-    Status onProgressUpdate(int32_t /* in_jobId */, int32_t in_progress) override {
+    Status onProgressUpdate(int32_t /* in_sessionId */, int32_t in_progress) override {
         updateProgress(in_progress);
         return Status::ok();
     }
@@ -354,13 +355,13 @@
     }
 
     template <bool expectation = success>
-    bool submit(int32_t jobId, const char* sourceFilePath, const char* destinationFilePath,
-                TranscodingJobPriority priority = TranscodingJobPriority::kNormal,
+    bool submit(int32_t sessionId, const char* sourceFilePath, const char* destinationFilePath,
+                TranscodingSessionPriority priority = TranscodingSessionPriority::kNormal,
                 int bitrateBps = -1, int overridePid = -1, int overrideUid = -1) {
         constexpr bool shouldSucceed = (expectation == success);
         bool result;
         TranscodingRequestParcel request;
-        TranscodingJobParcel job;
+        TranscodingSessionParcel session;
 
         request.sourceFilePath = sourceFilePath;
         request.destinationFilePath = destinationFilePath;
@@ -371,22 +372,23 @@
             request.requestedVideoTrackFormat.emplace(TranscodingVideoTrackFormat());
             request.requestedVideoTrackFormat->bitrateBps = bitrateBps;
         }
-        Status status = mClient->submitRequest(request, &job, &result);
+        Status status = mClient->submitRequest(request, &session, &result);
 
         EXPECT_TRUE(status.isOk());
         EXPECT_EQ(result, shouldSucceed);
         if (shouldSucceed) {
-            EXPECT_EQ(job.jobId, jobId);
+            EXPECT_EQ(session.sessionId, sessionId);
         }
 
-        return status.isOk() && (result == shouldSucceed) && (!shouldSucceed || job.jobId == jobId);
+        return status.isOk() && (result == shouldSucceed) &&
+               (!shouldSucceed || session.sessionId == sessionId);
     }
 
     template <bool expectation = success>
-    bool cancel(int32_t jobId) {
+    bool cancel(int32_t sessionId) {
         constexpr bool shouldSucceed = (expectation == success);
         bool result;
-        Status status = mClient->cancelJob(jobId, &result);
+        Status status = mClient->cancelSession(sessionId, &result);
 
         EXPECT_TRUE(status.isOk());
         EXPECT_EQ(result, shouldSucceed);
@@ -395,23 +397,24 @@
     }
 
     template <bool expectation = success>
-    bool getJob(int32_t jobId, const char* sourceFilePath, const char* destinationFilePath) {
+    bool getSession(int32_t sessionId, const char* sourceFilePath,
+                    const char* destinationFilePath) {
         constexpr bool shouldSucceed = (expectation == success);
         bool result;
-        TranscodingJobParcel job;
-        Status status = mClient->getJobWithId(jobId, &job, &result);
+        TranscodingSessionParcel session;
+        Status status = mClient->getSessionWithId(sessionId, &session, &result);
 
         EXPECT_TRUE(status.isOk());
         EXPECT_EQ(result, shouldSucceed);
         if (shouldSucceed) {
-            EXPECT_EQ(job.jobId, jobId);
-            EXPECT_EQ(job.request.sourceFilePath, sourceFilePath);
+            EXPECT_EQ(session.sessionId, sessionId);
+            EXPECT_EQ(session.request.sourceFilePath, sourceFilePath);
         }
 
         return status.isOk() && (result == shouldSucceed) &&
-               (!shouldSucceed ||
-                (job.jobId == jobId && job.request.sourceFilePath == sourceFilePath &&
-                 job.request.destinationFilePath == destinationFilePath));
+               (!shouldSucceed || (session.sessionId == sessionId &&
+                                   session.request.sourceFilePath == sourceFilePath &&
+                                   session.request.destinationFilePath == destinationFilePath));
     }
 
     int32_t mClientId;
diff --git a/services/mediatranscoding/tests/mediatranscodingservice_real_tests.cpp b/services/mediatranscoding/tests/mediatranscodingservice_real_tests.cpp
index 381bbf5..0550d77 100644
--- a/services/mediatranscoding/tests/mediatranscodingservice_real_tests.cpp
+++ b/services/mediatranscoding/tests/mediatranscodingservice_real_tests.cpp
@@ -34,7 +34,7 @@
 namespace media {
 
 constexpr int64_t kPaddingUs = 400000;
-constexpr int64_t kJobWithPaddingUs = 10000000 + kPaddingUs;
+constexpr int64_t kSessionWithPaddingUs = 10000000 + kPaddingUs;
 constexpr int32_t kBitRate = 8 * 1000 * 1000;  // 8Mbs
 
 constexpr const char* kShortSrcPath =
@@ -59,8 +59,9 @@
     const char* dstPath = OUTPATH(TestInvalidSource);
     deleteFile(dstPath);
 
-    // Submit one job.
-    EXPECT_TRUE(mClient1->submit(0, srcPath, dstPath, TranscodingJobPriority::kNormal, kBitRate));
+    // Submit one session.
+    EXPECT_TRUE(
+            mClient1->submit(0, srcPath, dstPath, TranscodingSessionPriority::kNormal, kBitRate));
 
     // Check expected error.
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Failed(CLIENT(1), 0));
@@ -75,12 +76,12 @@
     const char* dstPath = OUTPATH(TestPassthru);
     deleteFile(dstPath);
 
-    // Submit one job.
+    // Submit one session.
     EXPECT_TRUE(mClient1->submit(0, kShortSrcPath, dstPath));
 
-    // Wait for job to finish.
+    // Wait for session to finish.
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
-    EXPECT_EQ(mClient1->pop(kJobWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));
+    EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));
 
     unregisterMultipleClients();
 }
@@ -91,13 +92,13 @@
     const char* dstPath = OUTPATH(TestTranscodeVideo);
     deleteFile(dstPath);
 
-    // Submit one job.
-    EXPECT_TRUE(
-            mClient1->submit(0, kShortSrcPath, dstPath, TranscodingJobPriority::kNormal, kBitRate));
+    // Submit one session.
+    EXPECT_TRUE(mClient1->submit(0, kShortSrcPath, dstPath, TranscodingSessionPriority::kNormal,
+                                 kBitRate));
 
-    // Wait for job to finish.
+    // Wait for session to finish.
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
-    EXPECT_EQ(mClient1->pop(kJobWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));
+    EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));
 
     unregisterMultipleClients();
 }
@@ -108,13 +109,13 @@
     const char* dstPath = OUTPATH(TestTranscodeVideoProgress);
     deleteFile(dstPath);
 
-    // Submit one job.
-    EXPECT_TRUE(
-            mClient1->submit(0, kLongSrcPath, dstPath, TranscodingJobPriority::kNormal, kBitRate));
+    // Submit one session.
+    EXPECT_TRUE(mClient1->submit(0, kLongSrcPath, dstPath, TranscodingSessionPriority::kNormal,
+                                 kBitRate));
 
-    // Wait for job to finish.
+    // Wait for session to finish.
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
-    EXPECT_EQ(mClient1->pop(kJobWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));
+    EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));
 
     // Check the progress update messages are received. For this clip (around ~15 second long),
     // expect at least 10 updates, and the last update should be 100.
@@ -133,24 +134,26 @@
 
     const char* srcPath0 = kLongSrcPath;
     const char* srcPath1 = kShortSrcPath;
-    const char* dstPath0 = OUTPATH(TestCancelImmediately_Job0);
-    const char* dstPath1 = OUTPATH(TestCancelImmediately_Job1);
+    const char* dstPath0 = OUTPATH(TestCancelImmediately_Session0);
+    const char* dstPath1 = OUTPATH(TestCancelImmediately_Session1);
 
     deleteFile(dstPath0);
     deleteFile(dstPath1);
-    // Submit one job, should start immediately.
-    EXPECT_TRUE(mClient1->submit(0, srcPath0, dstPath0, TranscodingJobPriority::kNormal, kBitRate));
+    // Submit one session, should start immediately.
+    EXPECT_TRUE(
+            mClient1->submit(0, srcPath0, dstPath0, TranscodingSessionPriority::kNormal, kBitRate));
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
-    EXPECT_TRUE(mClient1->getJob(0, srcPath0, dstPath0));
+    EXPECT_TRUE(mClient1->getSession(0, srcPath0, dstPath0));
 
-    // Test cancel job immediately, getJob should fail after cancel.
+    // Test cancel session immediately, getSession should fail after cancel.
     EXPECT_TRUE(mClient1->cancel(0));
-    EXPECT_TRUE(mClient1->getJob<fail>(0, "", ""));
+    EXPECT_TRUE(mClient1->getSession<fail>(0, "", ""));
 
-    // Submit new job, new job should start immediately and finish.
-    EXPECT_TRUE(mClient1->submit(1, srcPath1, dstPath1, TranscodingJobPriority::kNormal, kBitRate));
+    // Submit new session, new session should start immediately and finish.
+    EXPECT_TRUE(
+            mClient1->submit(1, srcPath1, dstPath1, TranscodingSessionPriority::kNormal, kBitRate));
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 1));
-    EXPECT_EQ(mClient1->pop(kJobWithPaddingUs), EventTracker::Finished(CLIENT(1), 1));
+    EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 1));
 
     unregisterMultipleClients();
 }
@@ -163,26 +166,28 @@
 
     const char* srcPath0 = kLongSrcPath;
     const char* srcPath1 = kShortSrcPath;
-    const char* dstPath0 = OUTPATH(TestCancelWhileRunning_Job0);
-    const char* dstPath1 = OUTPATH(TestCancelWhileRunning_Job1);
+    const char* dstPath0 = OUTPATH(TestCancelWhileRunning_Session0);
+    const char* dstPath1 = OUTPATH(TestCancelWhileRunning_Session1);
 
     deleteFile(dstPath0);
     deleteFile(dstPath1);
-    // Submit two jobs, job 0 should start immediately, job 1 should be queued.
-    EXPECT_TRUE(mClient1->submit(0, srcPath0, dstPath0, TranscodingJobPriority::kNormal, kBitRate));
-    EXPECT_TRUE(mClient1->submit(1, srcPath1, dstPath1, TranscodingJobPriority::kNormal, kBitRate));
+    // Submit two sessions, session 0 should start immediately, session 1 should be queued.
+    EXPECT_TRUE(
+            mClient1->submit(0, srcPath0, dstPath0, TranscodingSessionPriority::kNormal, kBitRate));
+    EXPECT_TRUE(
+            mClient1->submit(1, srcPath1, dstPath1, TranscodingSessionPriority::kNormal, kBitRate));
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
-    EXPECT_TRUE(mClient1->getJob(0, srcPath0, dstPath0));
-    EXPECT_TRUE(mClient1->getJob(1, srcPath1, dstPath1));
+    EXPECT_TRUE(mClient1->getSession(0, srcPath0, dstPath0));
+    EXPECT_TRUE(mClient1->getSession(1, srcPath1, dstPath1));
 
-    // Job 0 (longtest) shouldn't finish in 1 seconds.
+    // Session 0 (longtest) shouldn't finish in 1 seconds.
     EXPECT_EQ(mClient1->pop(1000000), EventTracker::NoEvent);
 
-    // Now cancel job 0. Job 1 should start immediately and finish.
+    // Now cancel session 0. Session 1 should start immediately and finish.
     EXPECT_TRUE(mClient1->cancel(0));
-    EXPECT_TRUE(mClient1->getJob<fail>(0, "", ""));
+    EXPECT_TRUE(mClient1->getSession<fail>(0, "", ""));
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 1));
-    EXPECT_EQ(mClient1->pop(kJobWithPaddingUs), EventTracker::Finished(CLIENT(1), 1));
+    EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 1));
 
     unregisterMultipleClients();
 }
@@ -192,48 +197,49 @@
 
     const char* srcPath0 = kLongSrcPath;
     const char* srcPath1 = kShortSrcPath;
-    const char* dstPath0 = OUTPATH(TestPauseResumeSingleClient_Job0);
-    const char* dstPath1 = OUTPATH(TestPauseResumeSingleClient_Job1);
+    const char* dstPath0 = OUTPATH(TestPauseResumeSingleClient_Session0);
+    const char* dstPath1 = OUTPATH(TestPauseResumeSingleClient_Session1);
     deleteFile(dstPath0);
     deleteFile(dstPath1);
 
-    // Submit one offline job, should start immediately.
-    EXPECT_TRUE(mClient1->submit(0, srcPath0, dstPath0, TranscodingJobPriority::kUnspecified,
+    // Submit one offline session, should start immediately.
+    EXPECT_TRUE(mClient1->submit(0, srcPath0, dstPath0, TranscodingSessionPriority::kUnspecified,
                                  kBitRate));
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
-    // Test get job after starts.
-    EXPECT_TRUE(mClient1->getJob(0, srcPath0, dstPath0));
+    // Test get session after starts.
+    EXPECT_TRUE(mClient1->getSession(0, srcPath0, dstPath0));
 
-    // Submit one realtime job.
-    EXPECT_TRUE(mClient1->submit(1, srcPath1, dstPath1, TranscodingJobPriority::kNormal, kBitRate));
+    // Submit one realtime session.
+    EXPECT_TRUE(
+            mClient1->submit(1, srcPath1, dstPath1, TranscodingSessionPriority::kNormal, kBitRate));
 
-    // Offline job should pause.
+    // Offline session should pause.
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Pause(CLIENT(1), 0));
-    EXPECT_TRUE(mClient1->getJob(0, srcPath0, dstPath0));
+    EXPECT_TRUE(mClient1->getSession(0, srcPath0, dstPath0));
 
-    // Realtime job should start immediately, and run to finish.
+    // Realtime session should start immediately, and run to finish.
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 1));
-    EXPECT_EQ(mClient1->pop(kJobWithPaddingUs), EventTracker::Finished(CLIENT(1), 1));
+    EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 1));
 
-    // Test get job after finish fails.
-    EXPECT_TRUE(mClient1->getJob<fail>(1, "", ""));
+    // Test get session after finish fails.
+    EXPECT_TRUE(mClient1->getSession<fail>(1, "", ""));
 
-    // Then offline job should resume.
+    // Then offline session should resume.
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Resume(CLIENT(1), 0));
-    // Test get job after resume.
-    EXPECT_TRUE(mClient1->getJob(0, srcPath0, dstPath0));
+    // Test get session after resume.
+    EXPECT_TRUE(mClient1->getSession(0, srcPath0, dstPath0));
 
-    // Offline job should finish.
-    EXPECT_EQ(mClient1->pop(kJobWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));
-    // Test get job after finish fails.
-    EXPECT_TRUE(mClient1->getJob<fail>(0, "", ""));
+    // Offline session should finish.
+    EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));
+    // Test get session after finish fails.
+    EXPECT_TRUE(mClient1->getSession<fail>(0, "", ""));
 
     unregisterMultipleClients();
 }
 
 /*
- * Basic test for pause/resume with two clients, with one job each.
- * Top app's job should preempt the other app's job.
+ * Basic test for pause/resume with two clients, with one session each.
+ * Top app's session should preempt the other app's session.
  */
 TEST_F(MediaTranscodingServiceRealTest, TestPauseResumeMultiClients) {
     ALOGD("TestPauseResumeMultiClients starting...");
@@ -256,33 +262,35 @@
     ALOGD("Moving app A to top...");
     EXPECT_TRUE(ShellHelper::Start(kClientPackageA, kTestActivityName));
 
-    // Submit job to Client1.
-    ALOGD("Submitting job to client1 (app A) ...");
-    EXPECT_TRUE(mClient1->submit(0, srcPath0, dstPath0, TranscodingJobPriority::kNormal, kBitRate));
+    // Submit session to Client1.
+    ALOGD("Submitting session to client1 (app A) ...");
+    EXPECT_TRUE(
+            mClient1->submit(0, srcPath0, dstPath0, TranscodingSessionPriority::kNormal, kBitRate));
 
-    // Client1's job should start immediately.
+    // Client1's session should start immediately.
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
 
     ALOGD("Moving app B to top...");
     EXPECT_TRUE(ShellHelper::Start(kClientPackageB, kTestActivityName));
 
-    // Client1's job should continue to run, since Client2 (app B) doesn't have any job.
+    // Client1's session should continue to run, since Client2 (app B) doesn't have any session.
     EXPECT_EQ(mClient1->pop(1000000), EventTracker::NoEvent);
 
-    // Submit job to Client2.
-    ALOGD("Submitting job to client2 (app B) ...");
-    EXPECT_TRUE(mClient2->submit(0, srcPath1, dstPath1, TranscodingJobPriority::kNormal, kBitRate));
+    // Submit session to Client2.
+    ALOGD("Submitting session to client2 (app B) ...");
+    EXPECT_TRUE(
+            mClient2->submit(0, srcPath1, dstPath1, TranscodingSessionPriority::kNormal, kBitRate));
 
-    // Client1's job should pause, client2's job should start.
+    // Client1's session should pause, client2's session should start.
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Pause(CLIENT(1), 0));
     EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Start(CLIENT(2), 0));
 
-    // Client2's job should finish, then Client1's job should resume.
-    EXPECT_EQ(mClient2->pop(kJobWithPaddingUs), EventTracker::Finished(CLIENT(2), 0));
+    // Client2's session should finish, then Client1's session should resume.
+    EXPECT_EQ(mClient2->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(2), 0));
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Resume(CLIENT(1), 0));
 
-    // Client1's job should finish.
-    EXPECT_EQ(mClient1->pop(kJobWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));
+    // Client1's session should finish.
+    EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));
 
     unregisterMultipleClients();
 
diff --git a/services/mediatranscoding/tests/mediatranscodingservice_resource_tests.cpp b/services/mediatranscoding/tests/mediatranscodingservice_resource_tests.cpp
index 31697d5..bf99efc 100644
--- a/services/mediatranscoding/tests/mediatranscodingservice_resource_tests.cpp
+++ b/services/mediatranscoding/tests/mediatranscodingservice_resource_tests.cpp
@@ -55,13 +55,13 @@
 /**
  * Basic testing for handling resource lost.
  *
- * This test starts a transcoding job (that's somewhat long and takes several seconds),
+ * This test starts a transcoding session (that's somewhat long and takes several seconds),
  * then launches an activity that allocates video codec instances until it hits insufficient
  * resource error. Because the activity is running in foreground,
  * ResourceManager would reclaim codecs from transcoding service which should
- * cause the job to be paused. The activity will hold the codecs for a few seconds
+ * cause the session to be paused. The activity will hold the codecs for a few seconds
  * before releasing them, and the transcoding service should be able to resume
- * and complete the job.
+ * and complete the session.
  */
 TEST_F(MediaTranscodingServiceResourceTest, TestResourceLost) {
     ALOGD("TestResourceLost starting...");
@@ -79,21 +79,22 @@
     ALOGD("Moving app A to top...");
     EXPECT_TRUE(ShellHelper::Start(kClientPackageA, kTestActivityName));
 
-    // Submit job to Client1.
-    ALOGD("Submitting job to client1 (app A) ...");
-    EXPECT_TRUE(mClient1->submit(0, srcPath0, dstPath0, TranscodingJobPriority::kNormal, kBitRate));
+    // Submit session to Client1.
+    ALOGD("Submitting session to client1 (app A) ...");
+    EXPECT_TRUE(
+            mClient1->submit(0, srcPath0, dstPath0, TranscodingSessionPriority::kNormal, kBitRate));
 
-    // Client1's job should start immediately.
+    // Client1's session should start immediately.
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
 
     // Launch ResourcePolicyTestActivity, which will try to allocate up to 32
     // instances, which should trigger insufficient resources on most devices.
     // (Note that it's possible that the device supports a very high number of
-    // resource instances, in which case we'll simply require that the job completes.)
+    // resource instances, in which case we'll simply require that the session completes.)
     ALOGD("Launch ResourcePolicyTestActivity...");
     EXPECT_TRUE(ShellHelper::Start(kClientPackageA, kResourcePolicyTestActivity));
 
-    // The basic requirement is that the job should complete. Wait for finish
+    // The basic requirement is that the session should complete. Wait for finish
     // event to come and pop up all events received.
     std::list<EventTracker::Event> events;
     EXPECT_TRUE(mClient1->waitForSpecificEventAndPop(EventTracker::Finished(CLIENT(1), 0), &events,
diff --git a/services/mediatranscoding/tests/mediatranscodingservice_simulated_tests.cpp b/services/mediatranscoding/tests/mediatranscodingservice_simulated_tests.cpp
index 789b493..7dfda44 100644
--- a/services/mediatranscoding/tests/mediatranscodingservice_simulated_tests.cpp
+++ b/services/mediatranscoding/tests/mediatranscodingservice_simulated_tests.cpp
@@ -23,9 +23,9 @@
 #include <aidl/android/media/IMediaTranscodingService.h>
 #include <aidl/android/media/ITranscodingClient.h>
 #include <aidl/android/media/ITranscodingClientCallback.h>
-#include <aidl/android/media/TranscodingJobParcel.h>
-#include <aidl/android/media/TranscodingJobPriority.h>
 #include <aidl/android/media/TranscodingRequestParcel.h>
+#include <aidl/android/media/TranscodingSessionParcel.h>
+#include <aidl/android/media/TranscodingSessionPriority.h>
 #include <android-base/logging.h>
 #include <android/binder_manager.h>
 #include <android/binder_process.h>
@@ -44,15 +44,15 @@
 
 namespace media {
 
-// Note that -1 is valid and means using calling pid/uid for the service. But only privilege caller could
-// use them. This test is not a privilege caller.
+// Note that -1 is valid and means using calling pid/uid for the service. But only privilege caller
+// could use them. This test is not a privilege caller.
 constexpr int32_t kInvalidClientPid = -5;
 constexpr int32_t kInvalidClientUid = -10;
 constexpr const char* kInvalidClientName = "";
 constexpr const char* kInvalidClientOpPackageName = "";
 
 constexpr int64_t kPaddingUs = 1000000;
-constexpr int64_t kJobWithPaddingUs = SimulatedTranscoder::kJobDurationUs + kPaddingUs;
+constexpr int64_t kSessionWithPaddingUs = SimulatedTranscoder::kSessionDurationUs + kPaddingUs;
 
 constexpr const char* kClientOpPackageName = "TestClientPackage";
 
@@ -135,18 +135,18 @@
     unregisterMultipleClients();
 }
 
-TEST_F(MediaTranscodingServiceSimulatedTest, TestJobIdIndependence) {
+TEST_F(MediaTranscodingServiceSimulatedTest, TestSessionIdIndependence) {
     registerMultipleClients();
 
     // Submit 2 requests on client1 first.
     EXPECT_TRUE(mClient1->submit(0, "test_source_file", "test_destination_file"));
     EXPECT_TRUE(mClient1->submit(1, "test_source_file", "test_destination_file"));
 
-    // Submit 2 requests on client2, jobId should be independent for each client.
+    // Submit 2 requests on client2, sessionId should be independent for each client.
     EXPECT_TRUE(mClient2->submit(0, "test_source_file", "test_destination_file"));
     EXPECT_TRUE(mClient2->submit(1, "test_source_file", "test_destination_file"));
 
-    // Cancel all jobs.
+    // Cancel all sessions.
     EXPECT_TRUE(mClient1->cancel(0));
     EXPECT_TRUE(mClient1->cancel(1));
     EXPECT_TRUE(mClient2->cancel(0));
@@ -155,10 +155,10 @@
     unregisterMultipleClients();
 }
 
-TEST_F(MediaTranscodingServiceSimulatedTest, TestSubmitCancelJobs) {
+TEST_F(MediaTranscodingServiceSimulatedTest, TestSubmitCancelSessions) {
     registerMultipleClients();
 
-    // Test jobId assignment.
+    // Test sessionId assignment.
     EXPECT_TRUE(mClient1->submit(0, "test_source_file_0", "test_destination_file"));
     EXPECT_TRUE(mClient1->submit(1, "test_source_file_1", "test_destination_file"));
     EXPECT_TRUE(mClient1->submit(2, "test_source_file_2", "test_destination_file"));
@@ -167,33 +167,33 @@
     EXPECT_TRUE(mClient1->submit<fail>(0, "", ""));
 
     // Test submit bad request (no valid sourceFilePath) fails.
-    EXPECT_TRUE(mClient1->submit<fail>(0, "src", "dst", TranscodingJobPriority::kNormal, 1000000,
-                                       kInvalidClientPid, kInvalidClientUid));
+    EXPECT_TRUE(mClient1->submit<fail>(0, "src", "dst", TranscodingSessionPriority::kNormal,
+                                       1000000, kInvalidClientPid, kInvalidClientUid));
 
-    // Test cancel non-existent job fails.
+    // Test cancel non-existent session fails.
     EXPECT_TRUE(mClient1->cancel<fail>(100));
 
-    // Job 0 should start immediately and finish in 2 seconds, followed by Job 1 start.
+    // Session 0 should start immediately and finish in 2 seconds, followed by Session 1 start.
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
-    EXPECT_EQ(mClient1->pop(kJobWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));
+    EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 1));
 
-    // Test cancel valid jobId in random order.
-    // Test cancel finished job fails.
+    // Test cancel valid sessionId in random order.
+    // Test cancel finished session fails.
     EXPECT_TRUE(mClient1->cancel(2));
     EXPECT_TRUE(mClient1->cancel<fail>(0));
     EXPECT_TRUE(mClient1->cancel(1));
 
-    // Test cancel job again fails.
+    // Test cancel session again fails.
     EXPECT_TRUE(mClient1->cancel<fail>(1));
 
     // Test no more events arriving after cancel.
-    EXPECT_EQ(mClient1->pop(kJobWithPaddingUs), EventTracker::NoEvent);
+    EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::NoEvent);
 
     unregisterMultipleClients();
 }
 
-TEST_F(MediaTranscodingServiceSimulatedTest, TestGetJobs) {
+TEST_F(MediaTranscodingServiceSimulatedTest, TestGetSessions) {
     registerMultipleClients();
 
     // Submit 3 requests.
@@ -201,69 +201,69 @@
     EXPECT_TRUE(mClient1->submit(1, "test_source_file_1", "test_destination_file_1"));
     EXPECT_TRUE(mClient1->submit(2, "test_source_file_2", "test_destination_file_2"));
 
-    // Test get jobs by id.
-    EXPECT_TRUE(mClient1->getJob(2, "test_source_file_2", "test_destination_file_2"));
-    EXPECT_TRUE(mClient1->getJob(1, "test_source_file_1", "test_destination_file_1"));
-    EXPECT_TRUE(mClient1->getJob(0, "test_source_file_0", "test_destination_file_0"));
+    // Test get sessions by id.
+    EXPECT_TRUE(mClient1->getSession(2, "test_source_file_2", "test_destination_file_2"));
+    EXPECT_TRUE(mClient1->getSession(1, "test_source_file_1", "test_destination_file_1"));
+    EXPECT_TRUE(mClient1->getSession(0, "test_source_file_0", "test_destination_file_0"));
 
-    // Test get job by invalid id fails.
-    EXPECT_TRUE(mClient1->getJob<fail>(100, "", ""));
-    EXPECT_TRUE(mClient1->getJob<fail>(-1, "", ""));
+    // Test get session by invalid id fails.
+    EXPECT_TRUE(mClient1->getSession<fail>(100, "", ""));
+    EXPECT_TRUE(mClient1->getSession<fail>(-1, "", ""));
 
-    // Test get job after cancel fails.
+    // Test get session after cancel fails.
     EXPECT_TRUE(mClient1->cancel(2));
-    EXPECT_TRUE(mClient1->getJob<fail>(2, "", ""));
+    EXPECT_TRUE(mClient1->getSession<fail>(2, "", ""));
 
-    // Job 0 should start immediately and finish in 2 seconds, followed by Job 1 start.
+    // Session 0 should start immediately and finish in 2 seconds, followed by Session 1 start.
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
-    EXPECT_EQ(mClient1->pop(kJobWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));
+    EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 1));
 
-    // Test get job after finish fails.
-    EXPECT_TRUE(mClient1->getJob<fail>(0, "", ""));
+    // Test get session after finish fails.
+    EXPECT_TRUE(mClient1->getSession<fail>(0, "", ""));
 
-    // Test get the remaining job 1.
-    EXPECT_TRUE(mClient1->getJob(1, "test_source_file_1", "test_destination_file_1"));
+    // Test get the remaining session 1.
+    EXPECT_TRUE(mClient1->getSession(1, "test_source_file_1", "test_destination_file_1"));
 
-    // Cancel remaining job 1.
+    // Cancel remaining session 1.
     EXPECT_TRUE(mClient1->cancel(1));
 
     unregisterMultipleClients();
 }
 
-TEST_F(MediaTranscodingServiceSimulatedTest, TestSubmitCancelWithOfflineJobs) {
+TEST_F(MediaTranscodingServiceSimulatedTest, TestSubmitCancelWithOfflineSessions) {
     registerMultipleClients();
 
-    // Submit some offline jobs first.
+    // Submit some offline sessions first.
     EXPECT_TRUE(mClient1->submit(0, "test_source_file_0", "test_destination_file_0",
-                                 TranscodingJobPriority::kUnspecified));
+                                 TranscodingSessionPriority::kUnspecified));
     EXPECT_TRUE(mClient1->submit(1, "test_source_file_1", "test_destination_file_1",
-                                 TranscodingJobPriority::kUnspecified));
+                                 TranscodingSessionPriority::kUnspecified));
 
-    // Job 0 should start immediately.
+    // Session 0 should start immediately.
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
 
-    // Submit more real-time jobs.
+    // Submit more real-time sessions.
     EXPECT_TRUE(mClient1->submit(2, "test_source_file_2", "test_destination_file_2"));
     EXPECT_TRUE(mClient1->submit(3, "test_source_file_3", "test_destination_file_3"));
 
-    // Job 0 should pause immediately and job 2 should start.
+    // Session 0 should pause immediately and session 2 should start.
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Pause(CLIENT(1), 0));
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 2));
 
-    // Job 2 should finish in 2 seconds and job 3 should start.
-    EXPECT_EQ(mClient1->pop(kJobWithPaddingUs), EventTracker::Finished(CLIENT(1), 2));
+    // Session 2 should finish in 2 seconds and session 3 should start.
+    EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 2));
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 3));
 
-    // Cancel job 3 now
+    // Cancel session 3 now
     EXPECT_TRUE(mClient1->cancel(3));
 
-    // Job 0 should resume and finish in 2 seconds, followed by job 1 start.
+    // Session 0 should resume and finish in 2 seconds, followed by session 1 start.
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Resume(CLIENT(1), 0));
-    EXPECT_EQ(mClient1->pop(kJobWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));
+    EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 1));
 
-    // Cancel remaining job 1.
+    // Cancel remaining session 1.
     EXPECT_TRUE(mClient1->cancel(1));
 
     unregisterMultipleClients();
@@ -280,16 +280,16 @@
     EXPECT_TRUE(status.isOk());
 
     // Test various operations on the client, should fail with ERROR_DISCONNECTED.
-    TranscodingJobParcel job;
+    TranscodingSessionParcel session;
     bool result;
-    status = client->getJobWithId(0, &job, &result);
+    status = client->getSessionWithId(0, &session, &result);
     EXPECT_EQ(status.getServiceSpecificError(), IMediaTranscodingService::ERROR_DISCONNECTED);
 
-    status = client->cancelJob(0, &result);
+    status = client->cancelSession(0, &result);
     EXPECT_EQ(status.getServiceSpecificError(), IMediaTranscodingService::ERROR_DISCONNECTED);
 
     TranscodingRequestParcel request;
-    status = client->submitRequest(request, &job, &result);
+    status = client->submitRequest(request, &session, &result);
     EXPECT_EQ(status.getServiceSpecificError(), IMediaTranscodingService::ERROR_DISCONNECTED);
 }
 
@@ -308,41 +308,41 @@
     EXPECT_TRUE(ShellHelper::Start(kClientPackageA, kTestActivityName));
 
     // Submit 3 requests.
-    ALOGD("Submitting job to client1 (app A) ...");
+    ALOGD("Submitting session to client1 (app A) ...");
     EXPECT_TRUE(mClient1->submit(0, "test_source_file_0", "test_destination_file_0"));
     EXPECT_TRUE(mClient1->submit(1, "test_source_file_1", "test_destination_file_1"));
     EXPECT_TRUE(mClient1->submit(2, "test_source_file_2", "test_destination_file_2"));
 
-    // Job 0 should start immediately.
+    // Session 0 should start immediately.
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
 
     ALOGD("Moving app B to top...");
     EXPECT_TRUE(ShellHelper::Start(kClientPackageB, kTestActivityName));
 
-    // Job 0 should continue and finish in 2 seconds, then job 1 should start.
-    EXPECT_EQ(mClient1->pop(kJobWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));
+    // Session 0 should continue and finish in 2 seconds, then session 1 should start.
+    EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 1));
 
-    ALOGD("Submitting job to client2 (app B) ...");
+    ALOGD("Submitting session to client2 (app B) ...");
     EXPECT_TRUE(mClient2->submit(0, "test_source_file_0", "test_destination_file_0"));
 
-    // Client1's job should pause, client2's job should start.
+    // Client1's session should pause, client2's session should start.
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Pause(CLIENT(1), 1));
     EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Start(CLIENT(2), 0));
 
     ALOGD("Moving app A back to top...");
     EXPECT_TRUE(ShellHelper::Start(kClientPackageA, kTestActivityName));
 
-    // Client2's job should pause, client1's job 1 should resume.
+    // Client2's session should pause, client1's session 1 should resume.
     EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Pause(CLIENT(2), 0));
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Resume(CLIENT(1), 1));
 
-    // Client2's job 1 should finish in 2 seconds, then its job 2 should start.
-    EXPECT_EQ(mClient1->pop(kJobWithPaddingUs), EventTracker::Finished(CLIENT(1), 1));
+    // Client2's session 1 should finish in 2 seconds, then its session 2 should start.
+    EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 1));
     EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 2));
 
-    // After client2's jobs finish, client1's job should resume.
-    EXPECT_EQ(mClient1->pop(kJobWithPaddingUs), EventTracker::Finished(CLIENT(1), 2));
+    // After client2's sessions finish, client1's session should resume.
+    EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 2));
     EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Resume(CLIENT(2), 0));
 
     unregisterMultipleClients();