456 lines
18 KiB
C++
456 lines
18 KiB
C++
/*
|
|
* Copyright (C) 2019 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
// Unit Test for MediaTranscodingService.
|
|
|
|
//#define LOG_NDEBUG 0
|
|
#define LOG_TAG "MediaTranscodingServiceRealTest"
|
|
|
|
#include "MediaTranscodingServiceTestHelper.h"
|
|
|
|
/*
|
|
* Tests media transcoding service with real transcoder.
|
|
*
|
|
* Uses the same test assets as the MediaTranscoder unit tests. Before running the test,
|
|
* please make sure to push the test assets to /sdcard:
|
|
*
|
|
* adb push $TOP/frameworks/av/media/libmediatranscoding/transcoder/tests/assets /data/local/tmp/TranscodingTestAssets
|
|
*/
|
|
namespace android {
|
|
|
|
namespace media {
|
|
|
|
constexpr int64_t kPaddingUs = 1000000;
|
|
constexpr int64_t kSessionWithPaddingUs = 10000000 + kPaddingUs;
|
|
constexpr int32_t kBitRate = 8 * 1000 * 1000; // 8Mbs
|
|
|
|
constexpr const char* kShortSrcPath =
|
|
"/data/local/tmp/TranscodingTestAssets/cubicle_avc_480x240_aac_24KHz.mp4";
|
|
constexpr const char* kLongSrcPath = "/data/local/tmp/TranscodingTestAssets/longtest_15s.mp4";
|
|
|
|
#define OUTPATH(name) "/data/local/tmp/MediaTranscodingService_" #name ".MP4"
|
|
|
|
class MediaTranscodingServiceRealTest : public MediaTranscodingServiceTestBase {
|
|
public:
|
|
MediaTranscodingServiceRealTest() { ALOGI("MediaTranscodingServiceResourceTest created"); }
|
|
|
|
virtual ~MediaTranscodingServiceRealTest() {
|
|
ALOGI("MediaTranscodingServiceResourceTest destroyed");
|
|
}
|
|
};
|
|
|
|
TEST_F(MediaTranscodingServiceRealTest, TestInvalidSource) {
|
|
registerMultipleClients();
|
|
|
|
const char* srcPath = "bad_file_uri";
|
|
const char* dstPath = prepareOutputFile(OUTPATH(TestInvalidSource));
|
|
|
|
// 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));
|
|
EXPECT_EQ(mClient1->getLastError(), TranscodingErrorCode::kErrorIO);
|
|
|
|
unregisterMultipleClients();
|
|
}
|
|
|
|
TEST_F(MediaTranscodingServiceRealTest, TestPassthru) {
|
|
registerMultipleClients();
|
|
|
|
const char* dstPath = prepareOutputFile(OUTPATH(TestPassthru));
|
|
|
|
// Submit one session.
|
|
EXPECT_TRUE(mClient1->submit(0, kShortSrcPath, dstPath));
|
|
|
|
// Wait for session to finish.
|
|
EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
|
|
EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));
|
|
|
|
unregisterMultipleClients();
|
|
}
|
|
|
|
TEST_F(MediaTranscodingServiceRealTest, TestTranscodeVideo) {
|
|
registerMultipleClients();
|
|
|
|
const char* dstPath = prepareOutputFile(OUTPATH(TestTranscodeVideo));
|
|
|
|
// Submit one session.
|
|
EXPECT_TRUE(mClient1->submit(0, kShortSrcPath, dstPath, TranscodingSessionPriority::kNormal,
|
|
kBitRate));
|
|
|
|
// Wait for session to finish.
|
|
EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
|
|
EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));
|
|
|
|
unregisterMultipleClients();
|
|
}
|
|
|
|
TEST_F(MediaTranscodingServiceRealTest, TestTranscodeVideoProgress) {
|
|
registerMultipleClients();
|
|
|
|
const char* dstPath = prepareOutputFile(OUTPATH(TestTranscodeVideoProgress));
|
|
|
|
// Submit one session.
|
|
EXPECT_TRUE(mClient1->submit(0, kLongSrcPath, dstPath, TranscodingSessionPriority::kNormal,
|
|
kBitRate));
|
|
|
|
// Wait for session to finish.
|
|
EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(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.
|
|
int lastProgress;
|
|
EXPECT_GE(mClient1->getUpdateCount(&lastProgress), 10);
|
|
EXPECT_EQ(lastProgress, 100);
|
|
|
|
unregisterMultipleClients();
|
|
}
|
|
|
|
/*
|
|
* Test cancel immediately after start.
|
|
*/
|
|
TEST_F(MediaTranscodingServiceRealTest, TestCancelImmediately) {
|
|
registerMultipleClients();
|
|
|
|
const char* srcPath0 = kLongSrcPath;
|
|
const char* srcPath1 = kShortSrcPath;
|
|
const char* dstPath0 = prepareOutputFile(OUTPATH(TestCancelImmediately_Session0));
|
|
const char* dstPath1 = prepareOutputFile(OUTPATH(TestCancelImmediately_Session1));
|
|
|
|
// 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->getSession(0, srcPath0, dstPath0));
|
|
|
|
// Test cancel session immediately, getSession should fail after cancel.
|
|
EXPECT_TRUE(mClient1->cancel(0));
|
|
EXPECT_TRUE(mClient1->getSession<fail>(0, "", ""));
|
|
|
|
// 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(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 1));
|
|
|
|
unregisterMultipleClients();
|
|
}
|
|
|
|
/*
|
|
* Test cancel in the middle of transcoding.
|
|
*/
|
|
TEST_F(MediaTranscodingServiceRealTest, TestCancelWhileRunning) {
|
|
registerMultipleClients();
|
|
|
|
const char* srcPath0 = kLongSrcPath;
|
|
const char* srcPath1 = kShortSrcPath;
|
|
const char* dstPath0 = prepareOutputFile(OUTPATH(TestCancelWhileRunning_Session0));
|
|
const char* dstPath1 = prepareOutputFile(OUTPATH(TestCancelWhileRunning_Session1));
|
|
|
|
// 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->getSession(0, srcPath0, dstPath0));
|
|
EXPECT_TRUE(mClient1->getSession(1, srcPath1, dstPath1));
|
|
|
|
// Session 0 (longtest) shouldn't finish in 1 seconds.
|
|
EXPECT_EQ(mClient1->pop(1000000), EventTracker::NoEvent);
|
|
|
|
// Now cancel session 0. Session 1 should start immediately and finish.
|
|
EXPECT_TRUE(mClient1->cancel(0));
|
|
EXPECT_TRUE(mClient1->getSession<fail>(0, "", ""));
|
|
EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 1));
|
|
EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 1));
|
|
|
|
unregisterMultipleClients();
|
|
}
|
|
|
|
TEST_F(MediaTranscodingServiceRealTest, TestPauseResumeSingleClient) {
|
|
registerMultipleClients();
|
|
|
|
const char* srcPath0 = kLongSrcPath;
|
|
const char* srcPath1 = kShortSrcPath;
|
|
const char* dstPath0 = prepareOutputFile(OUTPATH(TestPauseResumeSingleClient_Session0));
|
|
const char* dstPath1 = prepareOutputFile(OUTPATH(TestPauseResumeSingleClient_Session1));
|
|
|
|
// 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 session after starts.
|
|
EXPECT_TRUE(mClient1->getSession(0, srcPath0, dstPath0));
|
|
|
|
// Submit one realtime session.
|
|
EXPECT_TRUE(
|
|
mClient1->submit(1, srcPath1, dstPath1, TranscodingSessionPriority::kNormal, kBitRate));
|
|
|
|
// Offline session should pause.
|
|
EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Pause(CLIENT(1), 0));
|
|
EXPECT_TRUE(mClient1->getSession(0, srcPath0, dstPath0));
|
|
|
|
// Realtime session should start immediately, and run to finish.
|
|
EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 1));
|
|
EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 1));
|
|
|
|
// Test get session after finish fails.
|
|
EXPECT_TRUE(mClient1->getSession<fail>(1, "", ""));
|
|
|
|
// Then offline session should resume.
|
|
EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Resume(CLIENT(1), 0));
|
|
// Test get session after resume.
|
|
EXPECT_TRUE(mClient1->getSession(0, srcPath0, dstPath0));
|
|
|
|
// 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 session each.
|
|
* Top app's session should preempt the other app's session.
|
|
*/
|
|
TEST_F(MediaTranscodingServiceRealTest, TestPauseResumeMultiClients) {
|
|
ALOGD("TestPauseResumeMultiClients starting...");
|
|
|
|
dismissKeyguard();
|
|
stopAppPackages();
|
|
|
|
registerMultipleClients();
|
|
|
|
const char* srcPath0 = kLongSrcPath;
|
|
const char* srcPath1 = kShortSrcPath;
|
|
const char* dstPath0 = prepareOutputFile(OUTPATH(TestPauseResumeMultiClients_Client0));
|
|
const char* dstPath1 = prepareOutputFile(OUTPATH(TestPauseResumeMultiClients_Client1));
|
|
|
|
ALOGD("Moving app A to top...");
|
|
EXPECT_TRUE(ShellHelper::Start(kClientPackageA, kTestActivityName));
|
|
|
|
// Submit session to Client1.
|
|
ALOGD("Submitting session to client1 (app A) ...");
|
|
EXPECT_TRUE(
|
|
mClient1->submit(0, srcPath0, dstPath0, TranscodingSessionPriority::kNormal, kBitRate));
|
|
|
|
// 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 session should continue to run, since Client2 (app B) doesn't have any session.
|
|
EXPECT_EQ(mClient1->pop(1000000), EventTracker::NoEvent);
|
|
|
|
// Submit session to Client2.
|
|
ALOGD("Submitting session to client2 (app B) ...");
|
|
EXPECT_TRUE(
|
|
mClient2->submit(0, srcPath1, dstPath1, TranscodingSessionPriority::kNormal, kBitRate));
|
|
|
|
// 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 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 session should finish.
|
|
EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 0));
|
|
|
|
unregisterMultipleClients();
|
|
|
|
stopAppPackages();
|
|
|
|
ALOGD("TestPauseResumeMultiClients finished.");
|
|
}
|
|
|
|
TEST_F(MediaTranscodingServiceRealTest, TestUidGoneForeground) {
|
|
ALOGD("TestUidGoneForeground starting...");
|
|
|
|
dismissKeyguard();
|
|
stopAppPackages();
|
|
|
|
registerMultipleClients();
|
|
|
|
const char* dstPath0 = prepareOutputFile(OUTPATH(TestUidGoneForegroundSession0));
|
|
const char* dstPath1 = prepareOutputFile(OUTPATH(TestUidGoneForegroundSession1));
|
|
|
|
// Test kill foreground app, using only 1 uid.
|
|
ALOGD("Moving app A to top...");
|
|
EXPECT_TRUE(ShellHelper::Start(kClientPackageA, kTestActivityName));
|
|
|
|
// Submit sessions to Client1 (app A).
|
|
ALOGD("Submitting sessions to client1 (app A) ...");
|
|
EXPECT_TRUE(mClient1->submit(0, kLongSrcPath, dstPath0, TranscodingSessionPriority::kNormal,
|
|
kBitRate));
|
|
EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
|
|
EXPECT_TRUE(mClient1->submit(1, kLongSrcPath, dstPath1, TranscodingSessionPriority::kNormal,
|
|
kBitRate));
|
|
EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::NoEvent);
|
|
|
|
// Kill app A, expect to see A's session pause followed by B's session start,
|
|
// then A's session cancelled with error code kUidGoneCancelled.
|
|
EXPECT_TRUE(ShellHelper::Stop(kClientPackageA));
|
|
EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Failed(CLIENT(1), 0));
|
|
EXPECT_EQ(mClient1->getLastError(), TranscodingErrorCode::kUidGoneCancelled);
|
|
EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Failed(CLIENT(1), 1));
|
|
EXPECT_EQ(mClient1->getLastError(), TranscodingErrorCode::kUidGoneCancelled);
|
|
|
|
unregisterMultipleClients();
|
|
|
|
stopAppPackages();
|
|
|
|
ALOGD("TestUidGoneForeground finished.");
|
|
}
|
|
|
|
TEST_F(MediaTranscodingServiceRealTest, TestUidGoneForegroundMultiUids) {
|
|
ALOGD("TestUidGoneForegroundMultiUids starting...");
|
|
|
|
dismissKeyguard();
|
|
stopAppPackages();
|
|
|
|
registerMultipleClients();
|
|
|
|
const char* dstPath0 = prepareOutputFile(OUTPATH(TestUidGoneForegroundSession0));
|
|
const char* dstPath1 = prepareOutputFile(OUTPATH(TestUidGoneForegroundSession1));
|
|
|
|
// Test kill foreground app, using two uids.
|
|
ALOGD("Moving app B to top...");
|
|
EXPECT_TRUE(ShellHelper::Start(kClientPackageB, kTestActivityName));
|
|
EXPECT_TRUE(mClient2->submit(0, kLongSrcPath, dstPath0, TranscodingSessionPriority::kNormal,
|
|
kBitRate));
|
|
EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Start(CLIENT(2), 0));
|
|
EXPECT_TRUE(mClient2->submit(1, kLongSrcPath, dstPath1, TranscodingSessionPriority::kNormal,
|
|
kBitRate));
|
|
EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::NoEvent);
|
|
// Make app A also requesting session 1.
|
|
EXPECT_TRUE(mClient2->addClientUid(1, mClient1->mClientUid));
|
|
|
|
ALOGD("Moving app A to top...");
|
|
EXPECT_TRUE(ShellHelper::Start(kClientPackageA, kTestActivityName));
|
|
EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Pause(CLIENT(2), 0));
|
|
EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Start(CLIENT(2), 1));
|
|
|
|
// Kill app A, CLIENT(2)'s session 1 should continue because it's also requested by app B.
|
|
EXPECT_TRUE(ShellHelper::Stop(kClientPackageA));
|
|
EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::NoEvent);
|
|
|
|
// Kill app B, sessions should be cancelled.
|
|
EXPECT_TRUE(ShellHelper::Stop(kClientPackageB));
|
|
EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Failed(CLIENT(2), 0));
|
|
EXPECT_EQ(mClient2->getLastError(), TranscodingErrorCode::kUidGoneCancelled);
|
|
EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Failed(CLIENT(2), 1));
|
|
EXPECT_EQ(mClient2->getLastError(), TranscodingErrorCode::kUidGoneCancelled);
|
|
|
|
unregisterMultipleClients();
|
|
|
|
stopAppPackages();
|
|
|
|
ALOGD("TestUidGoneForegroundMultiUids finished.");
|
|
}
|
|
TEST_F(MediaTranscodingServiceRealTest, TestUidGoneBackground) {
|
|
ALOGD("TestUidGoneBackground starting...");
|
|
|
|
dismissKeyguard();
|
|
stopAppPackages();
|
|
|
|
registerMultipleClients();
|
|
|
|
const char* dstPath0 = prepareOutputFile(OUTPATH(TestUidGoneForegroundSession0));
|
|
const char* dstPath1 = prepareOutputFile(OUTPATH(TestUidGoneForegroundSession1));
|
|
|
|
// Test kill background app, using two uids.
|
|
ALOGD("Moving app B to top...");
|
|
EXPECT_TRUE(ShellHelper::Start(kClientPackageB, kTestActivityName));
|
|
EXPECT_TRUE(mClient2->submit(0, kLongSrcPath, dstPath0, TranscodingSessionPriority::kNormal,
|
|
kBitRate));
|
|
EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Start(CLIENT(2), 0));
|
|
EXPECT_TRUE(mClient2->submit(1, kLongSrcPath, dstPath1, TranscodingSessionPriority::kNormal,
|
|
kBitRate));
|
|
EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::NoEvent);
|
|
|
|
ALOGD("Moving app A to top...");
|
|
EXPECT_TRUE(ShellHelper::Start(kClientPackageA, kTestActivityName));
|
|
EXPECT_TRUE(mClient1->submit(0, kLongSrcPath, dstPath0, TranscodingSessionPriority::kNormal,
|
|
kBitRate));
|
|
EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Pause(CLIENT(2), 0));
|
|
EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 0));
|
|
|
|
// Kill app B, all its sessions should be cancelled.
|
|
EXPECT_TRUE(ShellHelper::Stop(kClientPackageB));
|
|
EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Failed(CLIENT(2), 0));
|
|
EXPECT_EQ(mClient2->getLastError(), TranscodingErrorCode::kUidGoneCancelled);
|
|
EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Failed(CLIENT(2), 1));
|
|
EXPECT_EQ(mClient2->getLastError(), TranscodingErrorCode::kUidGoneCancelled);
|
|
|
|
unregisterMultipleClients();
|
|
|
|
stopAppPackages();
|
|
|
|
ALOGD("TestUidGoneBackground finished.");
|
|
}
|
|
|
|
TEST_F(MediaTranscodingServiceRealTest, TestUidGoneBackgroundMultiUids) {
|
|
ALOGD("TestUidGoneBackgroundMultiUids starting...");
|
|
|
|
dismissKeyguard();
|
|
stopAppPackages();
|
|
|
|
registerMultipleClients();
|
|
|
|
const char* dstPath0 = prepareOutputFile(OUTPATH(TestUidGoneForegroundSession0));
|
|
const char* dstPath1 = prepareOutputFile(OUTPATH(TestUidGoneForegroundSession1));
|
|
|
|
// Test kill background app, using two uids.
|
|
ALOGD("Moving app B to top...");
|
|
EXPECT_TRUE(ShellHelper::Start(kClientPackageB, kTestActivityName));
|
|
EXPECT_TRUE(mClient2->submit(0, kLongSrcPath, dstPath0, TranscodingSessionPriority::kNormal,
|
|
kBitRate));
|
|
EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Start(CLIENT(2), 0));
|
|
EXPECT_TRUE(mClient2->submit(1, kLongSrcPath, dstPath1, TranscodingSessionPriority::kNormal,
|
|
kBitRate));
|
|
EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::NoEvent);
|
|
// Make app A also requesting session 1.
|
|
EXPECT_TRUE(mClient2->addClientUid(1, mClient1->mClientUid));
|
|
|
|
ALOGD("Moving app A to top...");
|
|
EXPECT_TRUE(ShellHelper::Start(kClientPackageA, kTestActivityName));
|
|
EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Pause(CLIENT(2), 0));
|
|
EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Start(CLIENT(2), 1));
|
|
|
|
// Kill app B, CLIENT(2)'s session 1 should continue to run, session 0 on
|
|
// the other hand should be cancelled.
|
|
EXPECT_TRUE(ShellHelper::Stop(kClientPackageB));
|
|
EXPECT_EQ(mClient2->pop(kPaddingUs), EventTracker::Failed(CLIENT(2), 0));
|
|
EXPECT_EQ(mClient2->getLastError(), TranscodingErrorCode::kUidGoneCancelled);
|
|
|
|
unregisterMultipleClients();
|
|
|
|
stopAppPackages();
|
|
|
|
ALOGD("TestUidGoneBackgroundMultiUids finished.");
|
|
}
|
|
|
|
} // namespace media
|
|
} // namespace android
|