diff --git a/libraries/collectors-helper/memory/src/com/android/helpers/DumpsysMeminfoHelper.java b/libraries/collectors-helper/memory/src/com/android/helpers/DumpsysMeminfoHelper.java
new file mode 100644
index 0000000..168b3a2
--- /dev/null
+++ b/libraries/collectors-helper/memory/src/com/android/helpers/DumpsysMeminfoHelper.java
@@ -0,0 +1,173 @@
+/*
+ * 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
+ */
+
+package com.android.helpers;
+
+import android.support.test.uiautomator.UiDevice;
+import android.util.Log;
+
+import androidx.test.InstrumentationRegistry;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * This is a collector helper to use adb "dumpsys meminfo -a" command to get important memory
+ * metrics like PSS, Shared Dirty, Private Dirty, e.t.c. for the specified packages
+ */
+public class DumpsysMeminfoHelper implements ICollectorHelper<Long> {
+
+    private static final String TAG = DumpsysMeminfoHelper.class.getSimpleName();
+
+    private static final String SEPARATOR = "\\s+";
+    private static final String LINE_SEPARATOR = "\\n";
+
+    private static final String DUMPSYS_MEMINFO_CMD = "dumpsys meminfo -a %s";
+    private static final String PIDOF_CMD = "pidof %s";
+
+    private static final String METRIC_SOURCE = "dumpsys";
+    private static final String METRIC_UNIT = "kb";
+
+    // Prefixes of the lines in the output of "dumpsys meminfo -a" command that will be parsed
+    private static final String NATIVE_HEAP_PREFIX = "Native Heap";
+    private static final String DALVIK_HEAP_PREFIX = "Dalvik Heap";
+    private static final String TOTAL_PREFIX = "TOTAL";
+
+    // The metric names corresponding to the columns in the output of "dumpsys meminfo -a" command
+    private static final String PSS_TOTAL = "pss_total";
+    private static final String SHARED_DIRTY = "shared_dirty";
+    private static final String PRIVATE_DIRTY = "private_dirty";
+    private static final String HEAP_SIZE = "heap_size";
+    private static final String HEAP_ALLOC = "heap_alloc";
+    private static final String PSS = "pss";
+
+    // Mapping from prefixes of lines to metric category names
+    private static final Map<String, String> CATEGORIES =
+            Stream.of(
+                    new String[][] {
+                            {NATIVE_HEAP_PREFIX, "native"},
+                            {DALVIK_HEAP_PREFIX, "dalvik"},
+                            {TOTAL_PREFIX, "total"},
+                    }).collect(Collectors.toMap(data -> data[0], data -> data[1]));
+
+    // Mapping from metric keys to its column index (exclude prefix) in dumpsys meminfo output.
+    // The index might change across different Android releases
+    private static final Map<String, Integer> METRIC_POSITIONS =
+            Stream.of(
+                    new Object[][] {
+                            {PSS_TOTAL, 0},
+                            {SHARED_DIRTY, 2},
+                            {PRIVATE_DIRTY, 3},
+                            {HEAP_SIZE, 7},
+                            {HEAP_ALLOC, 8},
+                    })
+            .collect(Collectors.toMap(data -> (String) data[0], data -> (Integer) data[1]));
+
+    private String[] mProcessNames = {};
+    private UiDevice mUiDevice;
+
+    public void setUp(String... processNames) {
+        if (processNames == null) {
+            return;
+        }
+        mProcessNames = processNames;
+    }
+
+    @Override
+    public boolean startCollecting() {
+        mUiDevice = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
+        return true;
+    }
+
+    @Override
+    public Map<String, Long> getMetrics() {
+        Map<String, Long> metrics = new HashMap<>();
+        for (String processName : mProcessNames) {
+            String rawOutput = getRawDumpsysMeminfo(processName);
+            metrics.putAll(parseMetrics(processName, rawOutput));
+        }
+        return metrics;
+    }
+
+    @Override
+    public boolean stopCollecting() {
+        return true;
+    }
+
+    private String getRawDumpsysMeminfo(String processName) {
+        if (isEmpty(processName)) {
+            return "";
+        }
+        try {
+            String pidStr = mUiDevice.executeShellCommand(String.format(PIDOF_CMD, processName));
+            if (isEmpty(pidStr)) {
+                return "";
+            }
+            return mUiDevice.executeShellCommand(String.format(DUMPSYS_MEMINFO_CMD, pidStr));
+        } catch (IOException e) {
+            Log.e(TAG, String.format("Failed to execute command. %s", e));
+            return "";
+        }
+    }
+
+    private Map<String, Long> parseMetrics(String processName, String rawOutput) {
+        String[] lines = rawOutput.split(LINE_SEPARATOR);
+        Map<String, Long> metrics = new HashMap<>();
+        for (String line : lines) {
+            String[] tokens = line.trim().split(SEPARATOR);
+            if (tokens.length < 2) {
+                continue;
+            }
+            String firstToken = tokens[0];
+            String firstTwoTokens = String.join(" ", tokens[0], tokens[1]);
+            if (firstTwoTokens.equals(NATIVE_HEAP_PREFIX)
+                    || firstTwoTokens.equals(DALVIK_HEAP_PREFIX)) {
+                if (tokens.length < 11) {
+                    continue;
+                }
+                int offset = 2;
+                for (Map.Entry<String, Integer> metric : METRIC_POSITIONS.entrySet()) {
+                    metrics.put(
+                            MetricUtility.constructKey(
+                                    METRIC_SOURCE,
+                                    CATEGORIES.get(firstTwoTokens),
+                                    metric.getKey(),
+                                    METRIC_UNIT,
+                                    processName),
+                            Long.parseLong(tokens[offset + metric.getValue()]));
+                }
+            } else if (firstToken.equals(TOTAL_PREFIX)) {
+                int offset = 1;
+                metrics.put(
+                        MetricUtility.constructKey(
+                                METRIC_SOURCE,
+                                CATEGORIES.get(firstToken),
+                                PSS_TOTAL,
+                                METRIC_UNIT,
+                                processName),
+                        Long.parseLong(tokens[offset + METRIC_POSITIONS.get(PSS_TOTAL)]));
+            }
+        }
+        return metrics;
+    }
+
+    private boolean isEmpty(String input) {
+        return input == null || input.isEmpty();
+    }
+}
diff --git a/libraries/collectors-helper/memory/test/src/com/android/helpers/tests/DumpsysMeminfoHelperTest.java b/libraries/collectors-helper/memory/test/src/com/android/helpers/tests/DumpsysMeminfoHelperTest.java
new file mode 100644
index 0000000..1c337e4
--- /dev/null
+++ b/libraries/collectors-helper/memory/test/src/com/android/helpers/tests/DumpsysMeminfoHelperTest.java
@@ -0,0 +1,124 @@
+/*
+ * 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
+ */
+
+package com.android.helpers.tests;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import androidx.test.runner.AndroidJUnit4;
+
+import com.android.helpers.DumpsysMeminfoHelper;
+import com.android.helpers.MetricUtility;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.Map;
+
+/**
+ * Android unit test for {@link DumpsysMeminfoHelper}
+ *
+ * <p>To run: atest CollectorsHelperTest:com.android.helpers.tests.DumpsysMeminfoHelperTest
+ */
+@RunWith(AndroidJUnit4.class)
+public class DumpsysMeminfoHelperTest {
+
+    // Process name used for testing
+    private static final String TEST_PROCESS_NAME = "com.android.systemui";
+    // Second process name used for testing
+    private static final String TEST_PROCESS_NAME_2 = "system_server";
+    // A process that does not exists
+    private static final String PROCESS_NOT_FOUND = "process_not_found";
+
+    private static final String[] CATEGORIES = {"native", "dalvik"};
+
+    private static final String[] METRICS = {
+        "pss_total", "shared_dirty", "private_dirty", "heap_size", "heap_alloc"
+    };
+
+    private static final String UNIT = "kb";
+
+    private static final String METRIC_SOURCE = "dumpsys";
+
+    private DumpsysMeminfoHelper mDumpsysMeminfoHelper;
+
+    @Before
+    public void setUp() {
+        mDumpsysMeminfoHelper = new DumpsysMeminfoHelper();
+    }
+
+    @Test
+    public void testCollectMeminfo_noProcess() {
+        mDumpsysMeminfoHelper.startCollecting();
+        Map<String, Long> results = mDumpsysMeminfoHelper.getMetrics();
+        mDumpsysMeminfoHelper.stopCollecting();
+        assertTrue(results.isEmpty());
+    }
+
+    @Test
+    public void testCollectMeminfo_nullProcess() {
+        mDumpsysMeminfoHelper.setUp(null);
+        mDumpsysMeminfoHelper.startCollecting();
+        Map<String, Long> results = mDumpsysMeminfoHelper.getMetrics();
+        assertTrue(results.isEmpty());
+    }
+
+    @Test
+    public void testCollectMeminfo_wrongProcesses() {
+        mDumpsysMeminfoHelper.setUp(PROCESS_NOT_FOUND, null, "");
+        mDumpsysMeminfoHelper.startCollecting();
+        Map<String, Long> results = mDumpsysMeminfoHelper.getMetrics();
+        assertTrue(results.isEmpty());
+    }
+
+    @Test
+    public void testCollectMeminfo_oneProcess() {
+        mDumpsysMeminfoHelper.setUp(TEST_PROCESS_NAME);
+        mDumpsysMeminfoHelper.startCollecting();
+        Map<String, Long> results = mDumpsysMeminfoHelper.getMetrics();
+        mDumpsysMeminfoHelper.stopCollecting();
+        assertFalse(results.isEmpty());
+        verifyKeysForProcess(results, TEST_PROCESS_NAME);
+    }
+
+    @Test
+    public void testCollectMeminfo_multipleProcesses() {
+        mDumpsysMeminfoHelper.setUp(TEST_PROCESS_NAME, TEST_PROCESS_NAME_2);
+        mDumpsysMeminfoHelper.startCollecting();
+        Map<String, Long> results = mDumpsysMeminfoHelper.getMetrics();
+        mDumpsysMeminfoHelper.stopCollecting();
+        assertFalse(results.isEmpty());
+        verifyKeysForProcess(results, TEST_PROCESS_NAME);
+        verifyKeysForProcess(results, TEST_PROCESS_NAME_2);
+    }
+
+    private void verifyKeysForProcess(Map<String, Long> results, String processName) {
+        for (String category : CATEGORIES) {
+            for (String metric : METRICS) {
+                assertTrue(
+                        results.containsKey(
+                                MetricUtility.constructKey(
+                                        METRIC_SOURCE, category, metric, UNIT, processName)));
+            }
+        }
+        assertTrue(
+                results.containsKey(
+                        MetricUtility.constructKey(
+                                METRIC_SOURCE, "total", "pss_total", UNIT, processName)));
+    }
+}
diff --git a/libraries/device-collectors/src/main/java/android/device/collectors/DumpsysMeminfoListener.java b/libraries/device-collectors/src/main/java/android/device/collectors/DumpsysMeminfoListener.java
new file mode 100644
index 0000000..fae1619
--- /dev/null
+++ b/libraries/device-collectors/src/main/java/android/device/collectors/DumpsysMeminfoListener.java
@@ -0,0 +1,53 @@
+/*
+ * 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.
+ */
+
+package android.device.collectors;
+
+import android.device.collectors.annotations.OptionClass;
+import android.os.Bundle;
+import android.util.Log;
+
+import com.android.helpers.DumpsysMeminfoHelper;
+
+import com.google.common.annotations.VisibleForTesting;
+
+@OptionClass(alias = "dumpsys-meminfo-listener")
+public class DumpsysMeminfoListener extends BaseCollectionListener<Long> {
+
+    private static final String TAG = DumpsysMeminfoHelper.class.getSimpleName();
+    @VisibleForTesting static final String PROCESS_SEPARATOR = ",";
+    @VisibleForTesting static final String PROCESS_NAMES_KEY = "process-names";
+
+    public DumpsysMeminfoListener() {
+        createHelperInstance(new DumpsysMeminfoHelper());
+    }
+
+    @VisibleForTesting
+    public DumpsysMeminfoListener(Bundle args, DumpsysMeminfoHelper helper) {
+        super(args, helper);
+    }
+
+    @Override
+    public void setupAdditionalArgs() {
+        Bundle args = getArgsBundle();
+        String processesString = args.getString(PROCESS_NAMES_KEY);
+        if (processesString == null) {
+            Log.w(TAG, "No process name provided. Nothing will be collected");
+            return;
+        }
+        ((DumpsysMeminfoHelper) mHelper).setUp(processesString.split(PROCESS_SEPARATOR));
+    }
+}
diff --git a/libraries/device-collectors/src/test/java/android/device/collectors/DumpsysMeminfoListenerTest.java b/libraries/device-collectors/src/test/java/android/device/collectors/DumpsysMeminfoListenerTest.java
new file mode 100644
index 0000000..41e57d4
--- /dev/null
+++ b/libraries/device-collectors/src/test/java/android/device/collectors/DumpsysMeminfoListenerTest.java
@@ -0,0 +1,79 @@
+/*
+ * 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
+ */
+
+package android.device.collectors;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.MockitoAnnotations.initMocks;
+
+import android.app.Instrumentation;
+import android.os.Bundle;
+
+import androidx.test.runner.AndroidJUnit4;
+
+import com.android.helpers.DumpsysMeminfoHelper;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+
+/**
+ * Android Unit tests for {@link DumpsysMeminfoListener}.
+ *
+ * <p>To run: atest CollectorDeviceLibTest:android.device.collectors.DumpsysMeminfoListenerTest
+ */
+@RunWith(AndroidJUnit4.class)
+public class DumpsysMeminfoListenerTest {
+
+    @Mock private DumpsysMeminfoHelper mDumpsysMeminfoHelper;
+    @Mock private Instrumentation mInstrumentation;
+
+    private Description mRunDesc;
+
+    @Before
+    public void setup() {
+        initMocks(this);
+        mRunDesc = Description.createSuiteDescription("run");
+    }
+
+    @Test
+    public void testListener_noProcessNames() throws Exception {
+        DumpsysMeminfoListener listener = initListener(new Bundle(), mDumpsysMeminfoHelper);
+        listener.testRunStarted(mRunDesc);
+        verify(mDumpsysMeminfoHelper, never()).setUp(any());
+    }
+
+    @Test
+    public void testListener_withProcessNames() throws Exception {
+        Bundle bundle = new Bundle();
+        bundle.putString(
+                DumpsysMeminfoListener.PROCESS_NAMES_KEY,
+                String.join(DumpsysMeminfoListener.PROCESS_SEPARATOR, "process1", "process2"));
+        DumpsysMeminfoListener listener = initListener(bundle, mDumpsysMeminfoHelper);
+        listener.testRunStarted(mRunDesc);
+        verify(mDumpsysMeminfoHelper).setUp("process1", "process2");
+    }
+
+    private DumpsysMeminfoListener initListener(Bundle bundle, DumpsysMeminfoHelper helper) {
+        DumpsysMeminfoListener listener = new DumpsysMeminfoListener(bundle, helper);
+        listener.setInstrumentation(mInstrumentation);
+        return listener;
+    }
+}