io.appium.settings 4.0.9 → 4.1.1

package/README.md

@@ -321,6 +321,36 @@ and add them to the media library if their MIME types are supported. If the
 file/folder in _path_ does not exist/is not readable or is not provided then an
 error will be returned and the corresponding log message would be written into logs.
 
+## Internal Audio & Video Recording
+
+Required steps to activate recording:
+
+```bash
+adb shell pm grant io.appium.settings android.permission.RECORD_AUDIO
+adb shell appops set io.appium.settings PROJECT_MEDIA allow
+```
+
+Start Recording:
+```bash
+adb shell am start -n "io.appium.settings/io.appium.settings.Settings" -a io.appium.settings.recording.ACTION_START --es filename abc.mp4 --es priority high --es max_duration_sec 900 --es resolution 1920x1080
+```
+
+### Arguments (see above start command as an example for giving arguments)
+- filename (Mandatory) - You can type recording video file name as you want, but recording currently supports only "mp4" format so your filename must end with ".mp4"
+- priority (Optional) - Default value: "high" which means recording thread priority is maximum however if you face performance drops during testing with recording enabled, you can reduce recording priority to "normal" or "low"
+- max_duration_sec (Optional) (in seconds) - Default value: 900 seconds which means maximum allowed duration is 15 minute, you can increase it if your test takes longer than that
+- resolution (Optional) - Default value: maximum supported resolution on-device(Detected automatically on app itself), which usually equals to Full HD 1920x1080 on most phones however you can change it to following supported resolutions as well: "1920x1080", "1280x720", "720x480", "320x240", "176x144"
+
+Stop Recording:
+```bash
+adb shell am start -n "io.appium.settings/io.appium.settings.Settings" -a io.appium.settings.recording.ACTION_STOP
+```
+
+Obtain Recording Output File:
+```bash
+adb pull /storage/emulated/0/Android/data/io.appium.settings/files/abc.mp4 abc.mp4
+```
+
 
 ## Notes:
 

package/app/build.gradle

@@ -6,8 +6,8 @@ android {
     defaultConfig {
         minSdkVersion 18
         targetSdkVersion 30
-        versionCode 42
-        versionName "4.0.9"
+        versionCode 45
+        versionName "4.1.1"
         applicationId "io.appium.settings"
     }
 
@@ -27,7 +27,8 @@ android {
 }
 
 dependencies {
-    implementation 'com.google.android.gms:play-services-location:19.0.0'
+    implementation 'com.google.android.gms:play-services-location:19.0.1'
+    implementation 'org.apache.commons:commons-lang3:3.12.0'
 }
 
 static def renameAPK(variant) {

package/app/src/main/AndroidManifest.xml

@@ -28,6 +28,8 @@
     <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
     <uses-permission android:name="android.permission.READ_SMS" />
 
+    <uses-permission android:name="android.permission.RECORD_AUDIO"/>
+
     <uses-feature android:name="android.hardware.wifi" />
 
     <application
@@ -66,6 +68,12 @@
             android:exported="true">
         </service>
 
+        <service
+            android:foregroundServiceType="mediaProjection"
+            android:name=".recorder.RecorderService"
+            android:exported="true">
+        </service>
+
         <service
             android:name=".AppiumIME"
             android:label="Appium IME"

package/app/src/main/java/io/appium/settings/Settings.java

@@ -18,12 +18,17 @@ package io.appium.settings;
 
 import android.app.Activity;
 import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
 import android.content.IntentFilter;
+import android.media.projection.MediaProjectionManager;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.Handler;
 import android.util.Log;
 
+import java.io.File;
+import java.nio.file.Paths;
 import java.util.Arrays;
 import java.util.List;
 
@@ -39,10 +44,34 @@ import io.appium.settings.receivers.NotificationsReceiver;
 import io.appium.settings.receivers.SmsReader;
 import io.appium.settings.receivers.UnpairBluetoothDevicesReceiver;
 import io.appium.settings.receivers.WiFiConnectionSettingReceiver;
+import io.appium.settings.recorder.RecorderService;
+import io.appium.settings.recorder.RecorderUtil;
+
+import static io.appium.settings.recorder.RecorderConstant.ACTION_RECORDING_BASE;
+import static io.appium.settings.recorder.RecorderConstant.ACTION_RECORDING_FILENAME;
+import static io.appium.settings.recorder.RecorderConstant.ACTION_RECORDING_MAX_DURATION;
+import static io.appium.settings.recorder.RecorderConstant.ACTION_RECORDING_PRIORITY;
+import static io.appium.settings.recorder.RecorderConstant.ACTION_RECORDING_RESOLUTION;
+import static io.appium.settings.recorder.RecorderConstant.ACTION_RECORDING_RESULT_CODE;
+import static io.appium.settings.recorder.RecorderConstant.ACTION_RECORDING_ROTATION;
+import static io.appium.settings.recorder.RecorderConstant.ACTION_RECORDING_START;
+import static io.appium.settings.recorder.RecorderConstant.ACTION_RECORDING_STOP;
+import static io.appium.settings.recorder.RecorderConstant.NO_PATH_SET;
+import static io.appium.settings.recorder.RecorderConstant.NO_RESOLUTION_MODE_SET;
+import static io.appium.settings.recorder.RecorderConstant.RECORDING_MAX_DURATION_DEFAULT_MS;
+import static io.appium.settings.recorder.RecorderConstant.RECORDING_PRIORITY_DEFAULT;
+import static io.appium.settings.recorder.RecorderConstant.RECORDING_ROTATION_DEFAULT_DEGREE;
+import static io.appium.settings.recorder.RecorderConstant.REQUEST_CODE_SCREEN_CAPTURE;
 
 public class Settings extends Activity {
     private static final String TAG = "APPIUM SETTINGS";
 
+    private String recordingOutputPath = NO_PATH_SET;
+    private int recordingRotation = RECORDING_ROTATION_DEFAULT_DEGREE;
+    private int recordingPriority = RECORDING_PRIORITY_DEFAULT;
+    private int recordingMaxDuration = RECORDING_MAX_DURATION_DEFAULT_MS;
+    private String recordingResolutionMode = NO_RESOLUTION_MODE_SET;
+
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
@@ -70,12 +99,152 @@ public class Settings extends Activity {
             LocationTracker.getInstance().start(this);
         }
 
+        handleRecording(getIntent());
+    }
+
+    private void handleRecording(Intent intent) {
+        if (intent == null) {
+            Log.e(TAG, "handleRecording: Unable to retrieve intent instance");
+            finishActivity();
+            return;
+        }
+
+        String recordingAction = intent.getAction();
+        if (recordingAction == null) {
+            Log.e(TAG, "handleRecording: Unable to retrieve intent.action instance");
+            finishActivity();
+            return;
+        }
+
+        if (!recordingAction.startsWith(ACTION_RECORDING_BASE)) {
+            Log.i(TAG, "handleRecording: Received different intent with action: "
+                    + recordingAction);
+            finishActivity();
+            return;
+        }
+
+        if (RecorderUtil.isLowerThanQ()) {
+            Log.e(TAG, "handleRecording: Current Android OS Version is lower than Q");
+            finishActivity();
+            return;
+        }
+
+        if (!RecorderUtil.areRecordingPermissionsGranted(getApplicationContext())) {
+            Log.e(TAG, "handleRecording: Required permissions are not granted");
+            finishActivity();
+            return;
+        }
+
+        if (recordingAction.equals(ACTION_RECORDING_START)) {
+            String recordingFilename = intent.getStringExtra(ACTION_RECORDING_FILENAME);
+            if (!RecorderUtil.isValidFileName(recordingFilename)) {
+                Log.e(TAG, "handleRecording: Invalid filename passed by user: "
+                        + recordingFilename);
+                finishActivity();
+                return;
+            }
+
+            /*
+             External Storage File Directory for app
+             (i.e /storage/emulated/0/Android/data/io.appium.settings/files) may not be created
+             so we need to call getExternalFilesDir() method twice
+             source:https://www.androidbugfix.com/2021/10/getexternalfilesdirnull-returns-null-in.html
+            */
+            File externalStorageFile = getExternalFilesDir(null);
+            if (externalStorageFile == null) {
+                externalStorageFile = getExternalFilesDir(null);
+            }
+            // if path is still null despite calling method twice, early exit
+            if (externalStorageFile == null) {
+                Log.e(TAG, "handleRecording: Unable to retrieve external storage file path");
+                finishActivity();
+                return;
+            }
+
+            recordingOutputPath = Paths
+                    .get(externalStorageFile.getAbsolutePath(), recordingFilename)
+                    .toAbsolutePath()
+                    .toString();
+
+            recordingRotation = RecorderUtil.getDeviceRotationInDegree(getApplicationContext());
+
+            recordingPriority = RecorderUtil.getRecordingPriority(intent);
+
+            recordingMaxDuration = RecorderUtil.getRecordingMaxDuration(intent);
+
+            recordingResolutionMode = RecorderUtil.getRecordingResolutionMode(intent);
+
+            // start record
+            final MediaProjectionManager manager
+                    = (MediaProjectionManager) getSystemService(
+                    Context.MEDIA_PROJECTION_SERVICE);
+
+            if (manager == null) {
+                Log.e(TAG, "handleRecording: " +
+                        "Unable to retrieve MediaProjectionManager instance");
+                finishActivity();
+                return;
+            }
+
+            final Intent permissionIntent = manager.createScreenCaptureIntent();
+
+            startActivityForResult(permissionIntent, REQUEST_CODE_SCREEN_CAPTURE);
+        } else if (recordingAction.equals(ACTION_RECORDING_STOP)) {
+            // stop record
+            final Intent recorderIntent = new Intent(this, RecorderService.class);
+            recorderIntent.setAction(ACTION_RECORDING_STOP);
+            startService(recorderIntent);
+
+            finishActivity();
+        } else {
+            Log.e(TAG, "handleRecording: Unknown recording intent with action:"
+                    + recordingAction);
+            finishActivity();
+        }
+    }
+
+    private void finishActivity() {
         Log.d(TAG, "Closing the app");
         Handler handler = new Handler();
-        handler.postDelayed(Settings.this::finish, 1000);
+        handler.postDelayed(Settings.this::finish, 0);
+    }
+
+    @Override
+    protected void onActivityResult(final int requestCode, final int resultCode, final Intent data)
+    {
+        super.onActivityResult(requestCode, resultCode, data);
+        if (REQUEST_CODE_SCREEN_CAPTURE != requestCode) {
+            Log.e(TAG, "handleRecording: onActivityResult: " +
+                    "Received unknown request with code: " + requestCode);
+            finishActivity();
+            return;
+        }
+
+        if (resultCode != Activity.RESULT_OK) {
+            Log.e(TAG, "handleRecording: onActivityResult: " +
+                    "MediaProjection permission is not granted, " +
+                    "Did you apply appops adb command?");
+            finishActivity();
+            return;
+        }
+
+        final Intent intent = new Intent(this, RecorderService.class);
+        intent.setAction(ACTION_RECORDING_START);
+        intent.putExtra(ACTION_RECORDING_RESULT_CODE, resultCode);
+        intent.putExtra(ACTION_RECORDING_FILENAME, recordingOutputPath);
+        intent.putExtra(ACTION_RECORDING_ROTATION, recordingRotation);
+        intent.putExtra(ACTION_RECORDING_PRIORITY, recordingPriority);
+        intent.putExtra(ACTION_RECORDING_MAX_DURATION, recordingMaxDuration);
+        intent.putExtra(ACTION_RECORDING_RESOLUTION, recordingResolutionMode);
+        intent.putExtras(data);
+
+        startService(intent);
+
+        finishActivity();
     }
 
-    private void registerSettingsReceivers(List<Class<? extends BroadcastReceiver>> receiverClasses) {
+    private void registerSettingsReceivers(List<Class<? extends BroadcastReceiver>> receiverClasses)
+    {
         for (Class<? extends BroadcastReceiver> receiverClass: receiverClasses) {
             try {
                 final BroadcastReceiver receiver = receiverClass.newInstance();

package/app/src/main/java/io/appium/settings/receivers/LocaleSettingReceiver.java

@@ -16,11 +16,16 @@
 
 package io.appium.settings.receivers;
 
+import static org.apache.commons.lang3.StringUtils.isBlank;
+
+import android.app.Activity;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.util.Log;
 
+import org.apache.commons.lang3.LocaleUtils;
+
 import java.util.Locale;
 
 import io.appium.settings.handlers.LocaleSettingHandler;
@@ -37,40 +42,40 @@ public class LocaleSettingReceiver extends BroadcastReceiver implements HasActio
     // am broadcast -a io.appium.settings.locale --es lang ja --es country JP
     @Override
     public void onReceive(Context context, Intent intent) {
-        if(!hasExtraLocale(intent)) {
-            Log.e(TAG, "Don't forget to set lang and country like: am broadcast -a io.appium.settings.locale --es lang ja --es country JP");
-            Log.e(TAG, "Set en-US by default.");
-
-            intent.putExtra(LANG, "en");
-            intent.putExtra(COUNTRY, "US");
-        }
-
         String language = intent.getStringExtra(LANG);
         String country = intent.getStringExtra(COUNTRY);
-
+        if (language == null || country == null) {
+            Log.w(TAG, "It is required to provide both language and country, for example: " +
+                    "am broadcast -a io.appium.settings.locale --es lang ja --es country JP");
+            Log.i(TAG, "Set en-US by default.");
+            language = "en";
+            country= "US";
+        }
         // Expect https://developer.android.com/reference/java/util/Locale.html#Locale(java.lang.String,%20java.lang.String) format.
         Locale locale = new Locale(language, country);
-
-        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
-            String script = intent.getStringExtra(SCRIPT);
-
-            Locale.Builder builder = new Locale.Builder();
-            builder.setLocale(locale);
-            builder.setScript(script == null ? "" : script); // "Hans" part
-            locale = builder.build();
-            // "zh-Hans-CN" or "zh-CN" format
-            Log.i(TAG, "Set language tag: " + locale.toLanguageTag());
-        } else {
-            Log.i(TAG, "Set locale: " + locale.toString());
+        String script = intent.getStringExtra(SCRIPT);
+        if (!isBlank(script)) {
+            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
+                locale = new Locale.Builder().setLocale(locale).setScript(script).build();
+            } else {
+                Log.w(TAG, String.format("Script value '%s' is ignored as " +
+                        "setting of it is not supported by the current Android version", script));
+            }
+        }
+        if (!LocaleUtils.isAvailableLocale(locale)) {
+            Log.e(TAG, String.format(
+                    "The locale %s is not known. Only the following locales are available: %s",
+                    locale, LocaleUtils.availableLocaleList())
+            );
+            setResultCode(Activity.RESULT_CANCELED);
+            setResultData(String.format("The locale %s is not known", locale));
+            return;
         }
 
-        LocaleSettingHandler localeSettingHandler = new LocaleSettingHandler(context);
-
-        localeSettingHandler.setLocale(locale);
-    }
-
-    private boolean hasExtraLocale(Intent intent) {
-        return intent.hasExtra(LANG) && intent.hasExtra(COUNTRY);
+        new LocaleSettingHandler(context).setLocale(locale);
+        Log.i(TAG, String.format("Set locale: %s", locale));
+        setResultCode(Activity.RESULT_OK);
+        setResultData(locale.toString());
     }
 
     @Override

package/app/src/main/java/io/appium/settings/recorder/RecorderConstant.java

@@ -0,0 +1,94 @@
+/*
+  Copyright 2012-present Appium Committers
+  <p>
+  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
+  <p>
+  http://www.apache.org/licenses/LICENSE-2.0
+  <p>
+  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.
+ */
+
+package io.appium.settings.recorder;
+
+import android.media.MediaFormat;
+import android.os.Build;
+import android.util.Size;
+
+import java.util.Arrays;
+import java.util.List;
+
+import androidx.annotation.RequiresApi;
+import io.appium.settings.BuildConfig;
+
+public class RecorderConstant {
+    public static final int REQUEST_CODE_SCREEN_CAPTURE = 123;
+    public static final String ACTION_RECORDING_BASE = BuildConfig.APPLICATION_ID + ".recording";
+    public static final String ACTION_RECORDING_START = ACTION_RECORDING_BASE + ".ACTION_START";
+    public static final String ACTION_RECORDING_STOP = ACTION_RECORDING_BASE + ".ACTION_STOP";
+    public static final String ACTION_RECORDING_RESULT_CODE = "result_code";
+    public static final String ACTION_RECORDING_ROTATION = "recording_rotation";
+    public static final String ACTION_RECORDING_FILENAME = "filename";
+    public static final String ACTION_RECORDING_PRIORITY = "priority";
+    public static final String ACTION_RECORDING_MAX_DURATION = "max_duration_sec";
+    public static final String ACTION_RECORDING_RESOLUTION = "resolution";
+    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+    public static final String RECORDING_DEFAULT_VIDEO_MIME_TYPE = MediaFormat.MIMETYPE_VIDEO_AVC;
+    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+    public static final Size RECORDING_RESOLUTION_FULL_HD = new Size(1920, 1080);
+    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+    public static final Size RECORDING_RESOLUTION_HD = new Size(1280, 720);
+    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+    public static final Size RECORDING_RESOLUTION_480P = new Size(720, 480);
+    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+    public static final Size RECORDING_RESOLUTION_QVGA = new Size(320, 240);
+    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+    public static final Size RECORDING_RESOLUTION_QCIF = new Size(176, 144);
+    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+    public static final Size RECORDING_RESOLUTION_DEFAULT = new Size(1920, 1080);
+    public static final float BITRATE_MULTIPLIER = 0.25f;
+    public static final int AUDIO_CODEC_SAMPLE_RATE_HZ = 44100;
+    public static final int AUDIO_CODEC_CHANNEL_COUNT = 1;
+    public static final int AUDIO_CODEC_REPEAT_PREV_FRAME_AFTER_MS = 1000000;
+    public static final int AUDIO_CODEC_I_FRAME_INTERVAL_MS = 5;
+    public static final int AUDIO_CODEC_DEFAULT_BITRATE = 64000;
+    public static final int VIDEO_CODEC_DEFAULT_FRAME_RATE = 30;
+    public static final long MEDIA_QUEUE_BUFFERING_DEFAULT_TIMEOUT_MS = 10000;
+    public static final long NANOSECONDS_IN_MICROSECOND = 1000;
+    public static final String NO_PATH_SET = "";
+    public static final long NO_TIMESTAMP_SET = -1;
+    // Assume 0 degree == portrait as default
+    public static final int RECORDING_ROTATION_DEFAULT_DEGREE = 0;
+    public static final int NO_TRACK_INDEX_SET = -1;
+    public static final String NO_RESOLUTION_MODE_SET = "";
+    public static final String RECORDING_PRIORITY_MAX = "high";
+    public static final String RECORDING_PRIORITY_NORM = "normal";
+    public static final String RECORDING_PRIORITY_MIN = "low";
+    public static final int RECORDING_PRIORITY_DEFAULT = Thread.MAX_PRIORITY;
+    public static final int RECORDING_MAX_DURATION_DEFAULT_MS = 15 * 60 * 1000; // 15 Minutes, in milliseconds
+    /*
+    * Note: Reason we limit recording to following resolution list is that
+    * android's AVC/H264 video encoder capabilities varies device-to-device (OEM modifications)
+    * and with values larger than 1920x1080, isSizeSupported(width, height) method (see https://developer.android.com/reference/android/media/MediaCodecInfo.VideoCapabilities#isSizeSupported(int,%20int))
+    * returns false on tested devices and also with arbitrary values between supported range,
+    * sometimes MediaEncoder.configure() method crashes with an exception on some phones
+    * also default supported resolutions as per CTS tests are limited to following values (values between 176x144 and 1920x1080)
+    * see https://android.googlesource.com/platform/cts/+/refs/heads/android12-qpr1-release/tests/tests/media/src/android/media/cts/VideoEncoderTest.java#1766
+    * because of these reasons, to support wide variety of devices, we pre-limit resolution modes to the following values
+     */
+    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+    public static final List<Size> RECORDING_RESOLUTION_LIST =
+            Arrays.asList(
+                    new Size(1920, 1080),
+                    new Size(1280, 720),
+                    new Size(720, 480),
+                    new Size(320, 240),
+                    new Size(176, 144));
+    // 1048576 Bps == 1 Mbps (1024*1024)
+    public static final float BPS_IN_MBPS = 1048576f;
+}

package/app/src/main/java/io/appium/settings/recorder/RecorderService.java

@@ -0,0 +1,202 @@
+/*
+  Copyright 2012-present Appium Committers
+  <p>
+  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
+  <p>
+  http://www.apache.org/licenses/LICENSE-2.0
+  <p>
+  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.
+ */
+
+package io.appium.settings.recorder;
+
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.media.projection.MediaProjection;
+import android.media.projection.MediaProjectionManager;
+import android.os.Build;
+import android.os.IBinder;
+import android.util.DisplayMetrics;
+import android.util.Log;
+import android.util.Size;
+
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import io.appium.settings.helpers.NotificationHelpers;
+
+import static io.appium.settings.recorder.RecorderConstant.ACTION_RECORDING_FILENAME;
+import static io.appium.settings.recorder.RecorderConstant.ACTION_RECORDING_MAX_DURATION;
+import static io.appium.settings.recorder.RecorderConstant.ACTION_RECORDING_PRIORITY;
+import static io.appium.settings.recorder.RecorderConstant.ACTION_RECORDING_RESOLUTION;
+import static io.appium.settings.recorder.RecorderConstant.ACTION_RECORDING_RESULT_CODE;
+import static io.appium.settings.recorder.RecorderConstant.ACTION_RECORDING_ROTATION;
+import static io.appium.settings.recorder.RecorderConstant.ACTION_RECORDING_START;
+import static io.appium.settings.recorder.RecorderConstant.ACTION_RECORDING_STOP;
+import static io.appium.settings.recorder.RecorderConstant.RECORDING_MAX_DURATION_DEFAULT_MS;
+import static io.appium.settings.recorder.RecorderConstant.RECORDING_PRIORITY_DEFAULT;
+import static io.appium.settings.recorder.RecorderConstant.RECORDING_ROTATION_DEFAULT_DEGREE;
+
+public class RecorderService extends Service {
+    private static final String TAG = "RecorderService";
+
+    private static RecorderThread recorderThread;
+
+    public RecorderService() {
+        super();
+    }
+
+    @Override
+    public void onDestroy() {
+        Log.v(TAG, "onDestroy called: Stopping recorder");
+        if (recorderThread != null && recorderThread.isRecordingRunning()) {
+            recorderThread.stopRecording();
+        }
+        super.onDestroy();
+    }
+
+    @Nullable
+    @Override
+    public IBinder onBind(final Intent intent) {
+        return null;
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.Q)
+    @Override
+    public int onStartCommand(final Intent intent, final int flags, final int startId) {
+        if (intent == null) {
+            Log.e(TAG, "onStartCommand: Unable to retrieve recording intent");
+            return START_NOT_STICKY;
+        }
+        final String action = intent.getAction();
+        if (action == null) {
+            Log.e(TAG, "onStartCommand: Unable to retrieve recording intent:action");
+            return START_NOT_STICKY;
+        }
+
+        int result = START_STICKY;
+        if (ACTION_RECORDING_START.equals(action)) {
+            showNotification(); // TODO is this really necessary
+
+            MediaProjectionManager mMediaProjectionManager =
+                    (MediaProjectionManager) getSystemService(Context.MEDIA_PROJECTION_SERVICE);
+
+            if (mMediaProjectionManager != null) {
+                startRecord(mMediaProjectionManager, intent);
+            } else {
+                Log.e(TAG, "onStartCommand: " +
+                        "Unable to retrieve MediaProjectionManager instance");
+                result = START_NOT_STICKY;
+            }
+        } else if (ACTION_RECORDING_STOP.equals(action)) {
+            Log.v(TAG, "onStartCommand: Received recording stop intent, stopping recording");
+            stopRecord();
+            result = START_NOT_STICKY;
+        } else {
+            Log.v(TAG, "onStartCommand: Received unknown recording intent with action: "
+                    + action);
+            result = START_NOT_STICKY;
+        }
+
+        return result;
+    }
+
+    /**
+     * start recording
+     */
+    @RequiresApi(api = Build.VERSION_CODES.Q)
+    private void startRecord(MediaProjectionManager mediaProjectionManager,
+                             final Intent intent) {
+        if (recorderThread != null) {
+            if (recorderThread.isRecordingRunning()) {
+                Log.v(TAG, "Recording is already continuing, exiting");
+                return;
+            } else {
+                Log.w(TAG, "Recording is stopped, " +
+                        "but recording instance is still alive, starting recording");
+                recorderThread = null;
+            }
+        }
+
+        int resultCode = intent.getIntExtra(ACTION_RECORDING_RESULT_CODE, 0);
+        // get MediaProjection
+        final MediaProjection projection = mediaProjectionManager.getMediaProjection(resultCode,
+                intent);
+        if (projection == null) {
+            Log.e(TAG, "Recording is stopped, Unable to retrieve MediaProjection instance");
+            return;
+        }
+
+        String outputFilePath = intent.getStringExtra(ACTION_RECORDING_FILENAME);
+        if (outputFilePath == null) {
+            Log.e(TAG, "Recording is stopped, Unable to retrieve outputFilePath instance");
+            return;
+        }
+
+        /* TODO we need to rotate frames that comes from virtual screen before writing to file via muxer,
+         *  for handling landscape mode properly, we need to find a way to rotate images somehow fast and reliable
+         */
+        int recordingRotationDegree = intent.getIntExtra(ACTION_RECORDING_ROTATION,
+                RECORDING_ROTATION_DEFAULT_DEGREE);
+
+        DisplayMetrics metrics = getResources().getDisplayMetrics();
+        int rawWidth = metrics.widthPixels;
+        int rawHeight = metrics.heightPixels;
+        int rawDpi = metrics.densityDpi;
+
+        String recordingResolutionMode = intent.getStringExtra(ACTION_RECORDING_RESOLUTION);
+
+        Size recordingResolution = RecorderUtil.
+                getRecordingResolution(recordingResolutionMode);
+
+        int resolutionWidth = recordingResolution.getWidth();
+        int resolutionHeight = recordingResolution.getHeight();
+
+        /*
+        MediaCodec's tested supported resolutions (as per CTS tests) are for landscape mode as default (1920x1080, 1280x720 etc.)
+        but if phone or tablet is in portrait mode (usually it is),
+        we need to flip width/height to match it
+         */
+        if (rawWidth < rawHeight) {
+            resolutionWidth = recordingResolution.getHeight();
+            resolutionHeight = recordingResolution.getWidth();
+        }
+
+        Log.v(TAG, String.format("Starting recording with resolution(widthxheight): (%dx%d)",
+                resolutionWidth, resolutionHeight));
+
+        int recordingPriority = intent.getIntExtra(ACTION_RECORDING_PRIORITY,
+                RECORDING_PRIORITY_DEFAULT);
+
+        int recordingMaxDuration = intent.getIntExtra(ACTION_RECORDING_MAX_DURATION,
+                RECORDING_MAX_DURATION_DEFAULT_MS);
+
+        recorderThread = new RecorderThread(projection, outputFilePath,
+                resolutionWidth, resolutionHeight, rawDpi,
+                recordingRotationDegree, recordingPriority, recordingMaxDuration);
+        recorderThread.startRecording();
+    }
+
+    /**
+     * stop recording
+     */
+    private void stopRecord() {
+        if (recorderThread != null) {
+            recorderThread.stopRecording();
+            recorderThread = null;
+        }
+        stopSelf();
+    }
+
+    private void showNotification() {
+        // Set the info for the views that show in the notification panel.
+        startForeground(NotificationHelpers.APPIUM_NOTIFICATION_IDENTIFIER,
+                NotificationHelpers.getNotification(this));
+    }
+}