| /* |
| * Copyright (C) 2007 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.ddmlib; |
| |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.ddmlib.HeapSegment.HeapSegmentElement; |
| |
| import java.nio.BufferUnderflowException; |
| import java.nio.ByteBuffer; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.TreeMap; |
| import java.util.TreeSet; |
| |
| |
| /** |
| * Contains the data of a {@link Client}. |
| */ |
| public class ClientData { |
| /* This is a place to stash data associated with a Client, such as thread |
| * states or heap data. ClientData maps 1:1 to Client, but it's a little |
| * cleaner if we separate the data out. |
| * |
| * Message handlers are welcome to stash arbitrary data here. |
| * |
| * IMPORTANT: The data here is written by HandleFoo methods and read by |
| * FooPanel methods, which run in different threads. All non-trivial |
| * access should be synchronized against the ClientData object. |
| */ |
| |
| |
| /** Temporary name of VM to be ignored. */ |
| private static final String PRE_INITIALIZED = "<pre-initialized>"; //$NON-NLS-1$ |
| |
| public enum DebuggerStatus { |
| /** Debugger connection status: not waiting on one, not connected to one, but accepting |
| * new connections. This is the default value. */ |
| DEFAULT, |
| /** |
| * Debugger connection status: the application's VM is paused, waiting for a debugger to |
| * connect to it before resuming. */ |
| WAITING, |
| /** Debugger connection status : Debugger is connected */ |
| ATTACHED, |
| /** Debugger connection status: The listening port for debugger connection failed to listen. |
| * No debugger will be able to connect. */ |
| ERROR |
| } |
| |
| public enum AllocationTrackingStatus { |
| /** |
| * Allocation tracking status: unknown. |
| * <p/>This happens right after a {@link Client} is discovered |
| * by the {@link AndroidDebugBridge}, and before the {@link Client} answered the query |
| * regarding its allocation tracking status. |
| * @see Client#requestAllocationStatus() |
| */ |
| UNKNOWN, |
| /** Allocation tracking status: the {@link Client} is not tracking allocations. */ |
| OFF, |
| /** Allocation tracking status: the {@link Client} is tracking allocations. */ |
| ON |
| } |
| |
| public enum MethodProfilingStatus { |
| /** |
| * Method profiling status: unknown. |
| * <p/>This happens right after a {@link Client} is discovered |
| * by the {@link AndroidDebugBridge}, and before the {@link Client} answered the query |
| * regarding its method profiling status. |
| * @see Client#requestMethodProfilingStatus() |
| */ |
| UNKNOWN, |
| /** Method profiling status: the {@link Client} is not profiling method calls. */ |
| OFF, |
| /** Method profiling status: the {@link Client} is tracing method calls. */ |
| TRACER_ON, |
| /** Method profiling status: the {@link Client} is being profiled via sampling. */ |
| SAMPLER_ON |
| } |
| |
| /** |
| * String for feature enabling starting/stopping method profiling |
| * @see #hasFeature(String) |
| */ |
| public static final String FEATURE_PROFILING = "method-trace-profiling"; //$NON-NLS-1$ |
| |
| /** |
| * String for feature enabling direct streaming of method profiling data |
| * @see #hasFeature(String) |
| */ |
| public static final String FEATURE_PROFILING_STREAMING = "method-trace-profiling-streaming"; //$NON-NLS-1$ |
| |
| /** |
| * String for feature enabling sampling profiler. |
| * @see #hasFeature(String) |
| */ |
| public static final String FEATURE_SAMPLING_PROFILER = "method-sample-profiling"; //$NON-NLS-1$ |
| |
| /** |
| * String for feature indicating support for tracing OpenGL calls. |
| * @see #hasFeature(String) |
| */ |
| public static final String FEATURE_OPENGL_TRACING = "opengl-tracing"; //$NON-NLS-1$ |
| |
| /** |
| * String for feature indicating support for providing view hierarchy. |
| * @see #hasFeature(String) |
| */ |
| public static final String FEATURE_VIEW_HIERARCHY = "view-hierarchy"; //$NON-NLS-1$ |
| |
| /** |
| * String for feature allowing to dump hprof files |
| * @see #hasFeature(String) |
| */ |
| public static final String FEATURE_HPROF = "hprof-heap-dump"; //$NON-NLS-1$ |
| |
| /** |
| * String for feature allowing direct streaming of hprof dumps |
| * @see #hasFeature(String) |
| */ |
| public static final String FEATURE_HPROF_STREAMING = "hprof-heap-dump-streaming"; //$NON-NLS-1$ |
| |
| @Deprecated |
| private static IHprofDumpHandler sHprofDumpHandler; |
| private static IMethodProfilingHandler sMethodProfilingHandler; |
| private static IAllocationTrackingHandler sAllocationTrackingHandler; |
| |
| // is this a DDM-aware client? |
| private boolean mIsDdmAware; |
| |
| // the client's process ID |
| private final int mPid; |
| |
| // Java VM identification string |
| private String mVmIdentifier; |
| |
| // client's self-description |
| private String mClientDescription; |
| |
| // client's user id (on device in a multi user environment) |
| private int mUserId; |
| |
| // client's user id is valid |
| private boolean mValidUserId; |
| |
| // client's ABI |
| private String mAbi; |
| |
| // jvm flag: currently only indicates whether checkJni is enabled |
| private String mJvmFlags; |
| |
| // how interested are we in a debugger? |
| private DebuggerStatus mDebuggerInterest; |
| |
| // List of supported features by the client. |
| private final HashSet<String> mFeatures = new HashSet<String>(); |
| |
| // Thread tracking (THCR, THDE). |
| private TreeMap<Integer,ThreadInfo> mThreadMap; |
| |
| /** VM Heap data */ |
| private final HeapData mHeapData = new HeapData(); |
| /** Native Heap data */ |
| private final HeapData mNativeHeapData = new HeapData(); |
| |
| /** Hprof data */ |
| private HprofData mHprofData = null; |
| |
| private HashMap<Integer, HeapInfo> mHeapInfoMap = new HashMap<Integer, HeapInfo>(); |
| |
| /** library map info. Stored here since the backtrace data |
| * is computed on a need to display basis. |
| */ |
| private ArrayList<NativeLibraryMapInfo> mNativeLibMapInfo = |
| new ArrayList<NativeLibraryMapInfo>(); |
| |
| /** Native Alloc info list */ |
| private ArrayList<NativeAllocationInfo> mNativeAllocationList = |
| new ArrayList<NativeAllocationInfo>(); |
| private int mNativeTotalMemory; |
| |
| private AllocationInfo[] mAllocations; |
| private AllocationTrackingStatus mAllocationStatus = AllocationTrackingStatus.UNKNOWN; |
| |
| @Deprecated |
| private String mPendingHprofDump; |
| |
| private MethodProfilingStatus mProfilingStatus = MethodProfilingStatus.UNKNOWN; |
| private String mPendingMethodProfiling; |
| |
| /** |
| * Heap Information. |
| * <p/>The heap is composed of several {@link HeapSegment} objects. |
| * <p/>A call to {@link #isHeapDataComplete()} will indicate if the segments (available through |
| * {@link #getHeapSegments()}) represent the full heap. |
| */ |
| public static class HeapData { |
| private TreeSet<HeapSegment> mHeapSegments = new TreeSet<HeapSegment>(); |
| private boolean mHeapDataComplete = false; |
| private byte[] mProcessedHeapData; |
| private Map<Integer, ArrayList<HeapSegmentElement>> mProcessedHeapMap; |
| |
| /** |
| * Abandon the current list of heap segments. |
| */ |
| public synchronized void clearHeapData() { |
| /* Abandon the old segments instead of just calling .clear(). |
| * This lets the user hold onto the old set if it wants to. |
| */ |
| mHeapSegments = new TreeSet<HeapSegment>(); |
| mHeapDataComplete = false; |
| } |
| |
| /** |
| * Add raw HPSG chunk data to the list of heap segments. |
| * |
| * @param data The raw data from an HPSG chunk. |
| */ |
| synchronized void addHeapData(ByteBuffer data) { |
| HeapSegment hs; |
| |
| if (mHeapDataComplete) { |
| clearHeapData(); |
| } |
| |
| try { |
| hs = new HeapSegment(data); |
| } catch (BufferUnderflowException e) { |
| System.err.println("Discarding short HPSG data (length " + data.limit() + ")"); |
| return; |
| } |
| |
| mHeapSegments.add(hs); |
| } |
| |
| /** |
| * Called when all heap data has arrived. |
| */ |
| synchronized void sealHeapData() { |
| mHeapDataComplete = true; |
| } |
| |
| /** |
| * Returns whether the heap data has been sealed. |
| */ |
| public boolean isHeapDataComplete() { |
| return mHeapDataComplete; |
| } |
| |
| /** |
| * Get the collected heap data, if sealed. |
| * |
| * @return The list of heap segments if the heap data has been sealed, or null if it hasn't. |
| */ |
| public Collection<HeapSegment> getHeapSegments() { |
| if (isHeapDataComplete()) { |
| return mHeapSegments; |
| } |
| return null; |
| } |
| |
| /** |
| * Sets the processed heap data. |
| * |
| * @param heapData The new heap data (can be null) |
| */ |
| public void setProcessedHeapData(byte[] heapData) { |
| mProcessedHeapData = heapData; |
| } |
| |
| /** |
| * Get the processed heap data, if present. |
| * |
| * @return the processed heap data, or null. |
| */ |
| public byte[] getProcessedHeapData() { |
| return mProcessedHeapData; |
| } |
| |
| public void setProcessedHeapMap(Map<Integer, ArrayList<HeapSegmentElement>> heapMap) { |
| mProcessedHeapMap = heapMap; |
| } |
| |
| public Map<Integer, ArrayList<HeapSegmentElement>> getProcessedHeapMap() { |
| return mProcessedHeapMap; |
| } |
| } |
| |
| public static class HeapInfo { |
| public long maxSizeInBytes; |
| public long sizeInBytes; |
| public long bytesAllocated; |
| public long objectsAllocated; |
| public long timeStamp; |
| public byte reason; |
| |
| public HeapInfo(long maxSizeInBytes, |
| long sizeInBytes, |
| long bytesAllocated, |
| long objectsAllocated, |
| long timeStamp, |
| byte reason) { |
| this.maxSizeInBytes = maxSizeInBytes; |
| this.sizeInBytes = sizeInBytes; |
| this.bytesAllocated = bytesAllocated; |
| this.objectsAllocated = objectsAllocated; |
| this.timeStamp = timeStamp; |
| this.reason = reason; |
| } |
| } |
| |
| public static class HprofData { |
| public enum Type { |
| FILE, |
| DATA |
| } |
| |
| public final Type type; |
| public final String filename; |
| public final byte[] data; |
| |
| public HprofData(@NonNull String filename) { |
| type = Type.FILE; |
| this.filename = filename; |
| this.data = null; |
| } |
| |
| public HprofData(@NonNull byte[] data) { |
| type = Type.DATA; |
| this.data = data; |
| this.filename = null; |
| } |
| } |
| |
| /** |
| * Handlers able to act on HPROF dumps. |
| */ |
| @Deprecated |
| public interface IHprofDumpHandler { |
| /** |
| * Called when a HPROF dump succeeded. |
| * @param remoteFilePath the device-side path of the HPROF file. |
| * @param client the client for which the HPROF file was. |
| */ |
| void onSuccess(String remoteFilePath, Client client); |
| |
| /** |
| * Called when a HPROF dump was successful. |
| * @param data the data containing the HPROF file, streamed from the VM |
| * @param client the client that was profiled. |
| */ |
| void onSuccess(byte[] data, Client client); |
| |
| /** |
| * Called when a hprof dump failed to end on the VM side |
| * @param client the client that was profiled. |
| * @param message an optional (<code>null<code> ok) error message to be displayed. |
| */ |
| void onEndFailure(Client client, String message); |
| } |
| |
| /** |
| * Handlers able to act on Method profiling info |
| */ |
| public interface IMethodProfilingHandler { |
| /** |
| * Called when a method tracing was successful. |
| * @param remoteFilePath the device-side path of the trace file. |
| * @param client the client that was profiled. |
| */ |
| void onSuccess(String remoteFilePath, Client client); |
| |
| /** |
| * Called when a method tracing was successful. |
| * @param data the data containing the trace file, streamed from the VM |
| * @param client the client that was profiled. |
| */ |
| void onSuccess(byte[] data, Client client); |
| |
| /** |
| * Called when method tracing failed to start |
| * @param client the client that was profiled. |
| * @param message an optional (<code>null<code> ok) error message to be displayed. |
| */ |
| void onStartFailure(Client client, String message); |
| |
| /** |
| * Called when method tracing failed to end on the VM side |
| * @param client the client that was profiled. |
| * @param message an optional (<code>null<code> ok) error message to be displayed. |
| */ |
| void onEndFailure(Client client, String message); |
| } |
| |
| /* |
| * Handlers able to act on allocation tracking info |
| */ |
| public interface IAllocationTrackingHandler { |
| /** |
| * Called when an allocation tracking was successful. |
| * @param data the data containing the encoded allocations. |
| * See {@link AllocationsParser#parse(java.nio.ByteBuffer)} for parsing this data. |
| * @param client the client for which allocations were tracked. |
| */ |
| void onSuccess(@NonNull byte[] data, @NonNull Client client); |
| } |
| |
| public void setHprofData(byte[] data) { |
| mHprofData = new HprofData(data); |
| } |
| |
| public void setHprofData(String filename) { |
| mHprofData = new HprofData(filename); |
| } |
| |
| public void clearHprofData() { |
| mHprofData = null; |
| } |
| |
| public HprofData getHprofData() { |
| return mHprofData; |
| } |
| |
| /** |
| * Sets the handler to receive notifications when an HPROF dump succeeded or failed. |
| * This method is deprecated, please register a client listener and listen for CHANGE_HPROF. |
| */ |
| @Deprecated |
| public static void setHprofDumpHandler(IHprofDumpHandler handler) { |
| sHprofDumpHandler = handler; |
| } |
| |
| @Deprecated |
| static IHprofDumpHandler getHprofDumpHandler() { |
| return sHprofDumpHandler; |
| } |
| |
| /** |
| * Sets the handler to receive notifications when an HPROF dump succeeded or failed. |
| * This method is deprecated, please register a client listener and listen for CHANGE_HPROF. |
| */ |
| public static void setMethodProfilingHandler(IMethodProfilingHandler handler) { |
| sMethodProfilingHandler = handler; |
| } |
| |
| static IMethodProfilingHandler getMethodProfilingHandler() { |
| return sMethodProfilingHandler; |
| } |
| |
| public static void setAllocationTrackingHandler(@NonNull IAllocationTrackingHandler handler) { |
| sAllocationTrackingHandler = handler; |
| } |
| |
| @Nullable |
| static IAllocationTrackingHandler getAllocationTrackingHandler() { |
| return sAllocationTrackingHandler; |
| } |
| |
| /** |
| * Generic constructor. |
| */ |
| ClientData(int pid) { |
| mPid = pid; |
| |
| mDebuggerInterest = DebuggerStatus.DEFAULT; |
| mThreadMap = new TreeMap<Integer,ThreadInfo>(); |
| } |
| |
| /** |
| * Returns whether the process is DDM-aware. |
| */ |
| public boolean isDdmAware() { |
| return mIsDdmAware; |
| } |
| |
| /** |
| * Sets DDM-aware status. |
| */ |
| void isDdmAware(boolean aware) { |
| mIsDdmAware = aware; |
| } |
| |
| /** |
| * Returns the process ID. |
| */ |
| public int getPid() { |
| return mPid; |
| } |
| |
| /** |
| * Returns the Client's VM identifier. |
| */ |
| public String getVmIdentifier() { |
| return mVmIdentifier; |
| } |
| |
| /** |
| * Sets VM identifier. |
| */ |
| void setVmIdentifier(String ident) { |
| mVmIdentifier = ident; |
| } |
| |
| /** |
| * Returns the client description. |
| * <p/>This is generally the name of the package defined in the |
| * <code>AndroidManifest.xml</code>. |
| * |
| * @return the client description or <code>null</code> if not the description was not yet |
| * sent by the client. |
| */ |
| public String getClientDescription() { |
| return mClientDescription; |
| } |
| |
| /** |
| * Returns the client's user id. |
| * @return user id if set, -1 otherwise |
| */ |
| public int getUserId() { |
| return mUserId; |
| } |
| |
| /** |
| * Returns true if the user id of this client was set. Only devices that support multiple |
| * users will actually return the user id to ddms. For other/older devices, this will not |
| * be set. |
| */ |
| public boolean isValidUserId() { |
| return mValidUserId; |
| } |
| |
| /** Returns the abi flavor (32-bit or 64-bit) of the application, null if unknown or not set. */ |
| @Nullable |
| public String getAbi() { |
| return mAbi; |
| } |
| |
| /** Returns the VM flags in use, or null if unknown. */ |
| public String getJvmFlags() { |
| return mJvmFlags; |
| } |
| |
| /** |
| * Sets client description. |
| * |
| * There may be a race between HELO and APNM. Rather than try |
| * to enforce ordering on the device, we just don't allow an empty |
| * name to replace a specified one. |
| */ |
| void setClientDescription(String description) { |
| if (mClientDescription == null && !description.isEmpty()) { |
| /* |
| * The application VM is first named <pre-initialized> before being assigned |
| * its real name. |
| * Depending on the timing, we can get an APNM chunk setting this name before |
| * another one setting the final actual name. So if we get a SetClientDescription |
| * with this value we ignore it. |
| */ |
| if (!PRE_INITIALIZED.equals(description)) { |
| mClientDescription = description; |
| } |
| } |
| } |
| |
| void setUserId(int id) { |
| mUserId = id; |
| mValidUserId = true; |
| } |
| |
| void setAbi(String abi) { |
| mAbi = abi; |
| } |
| |
| void setJvmFlags(String jvmFlags) { |
| mJvmFlags = jvmFlags; |
| } |
| |
| /** |
| * Returns the debugger connection status. |
| */ |
| public DebuggerStatus getDebuggerConnectionStatus() { |
| return mDebuggerInterest; |
| } |
| |
| /** |
| * Sets debugger connection status. |
| */ |
| void setDebuggerConnectionStatus(DebuggerStatus status) { |
| mDebuggerInterest = status; |
| } |
| |
| /** |
| * Sets the current heap info values for the specified heap. |
| * @param heapId The heap whose info to update |
| * @param sizeInBytes The size of the heap, in bytes |
| * @param bytesAllocated The number of bytes currently allocated in the heap |
| * @param objectsAllocated The number of objects currently allocated in |
| * @param timeStamp |
| * @param reason |
| */ |
| synchronized void setHeapInfo(int heapId, |
| long maxSizeInBytes, |
| long sizeInBytes, |
| long bytesAllocated, |
| long objectsAllocated, |
| long timeStamp, |
| byte reason) { |
| mHeapInfoMap.put(heapId, new HeapInfo(maxSizeInBytes, sizeInBytes, bytesAllocated, |
| objectsAllocated, timeStamp, reason)); |
| } |
| |
| /** |
| * Returns the {@link HeapData} object for the VM. |
| */ |
| public HeapData getVmHeapData() { |
| return mHeapData; |
| } |
| |
| /** |
| * Returns the {@link HeapData} object for the native code. |
| */ |
| HeapData getNativeHeapData() { |
| return mNativeHeapData; |
| } |
| |
| /** |
| * Returns an iterator over the list of known VM heap ids. |
| * <p/> |
| * The caller must synchronize on the {@link ClientData} object while iterating. |
| * |
| * @return an iterator over the list of heap ids |
| */ |
| public synchronized Iterator<Integer> getVmHeapIds() { |
| return mHeapInfoMap.keySet().iterator(); |
| } |
| |
| /** |
| * Returns the most-recent info values for the specified VM heap. |
| * |
| * @param heapId The heap whose info should be returned |
| * @return a map containing the info values for the specified heap. |
| * Returns <code>null</code> if the heap ID is unknown. |
| */ |
| public synchronized HeapInfo getVmHeapInfo(int heapId) { |
| return mHeapInfoMap.get(heapId); |
| } |
| |
| /** |
| * Adds a new thread to the list. |
| */ |
| synchronized void addThread(int threadId, String threadName) { |
| ThreadInfo attr = new ThreadInfo(threadId, threadName); |
| mThreadMap.put(threadId, attr); |
| } |
| |
| /** |
| * Removes a thread from the list. |
| */ |
| synchronized void removeThread(int threadId) { |
| mThreadMap.remove(threadId); |
| } |
| |
| /** |
| * Returns the list of threads as {@link ThreadInfo} objects. |
| * <p/>The list is empty until a thread update was requested with |
| * {@link Client#requestThreadUpdate()}. |
| */ |
| public synchronized ThreadInfo[] getThreads() { |
| Collection<ThreadInfo> threads = mThreadMap.values(); |
| return threads.toArray(new ThreadInfo[threads.size()]); |
| } |
| |
| /** |
| * Returns the {@link ThreadInfo} by thread id. |
| */ |
| synchronized ThreadInfo getThread(int threadId) { |
| return mThreadMap.get(threadId); |
| } |
| |
| synchronized void clearThreads() { |
| mThreadMap.clear(); |
| } |
| |
| /** |
| * Returns the list of {@link NativeAllocationInfo}. |
| * @see Client#requestNativeHeapInformation() |
| */ |
| public synchronized List<NativeAllocationInfo> getNativeAllocationList() { |
| return Collections.unmodifiableList(mNativeAllocationList); |
| } |
| |
| /** |
| * adds a new {@link NativeAllocationInfo} to the {@link Client} |
| * @param allocInfo The {@link NativeAllocationInfo} to add. |
| */ |
| synchronized void addNativeAllocation(NativeAllocationInfo allocInfo) { |
| mNativeAllocationList.add(allocInfo); |
| } |
| |
| /** |
| * Clear the current malloc info. |
| */ |
| synchronized void clearNativeAllocationInfo() { |
| mNativeAllocationList.clear(); |
| } |
| |
| /** |
| * Returns the total native memory. |
| * @see Client#requestNativeHeapInformation() |
| */ |
| public synchronized int getTotalNativeMemory() { |
| return mNativeTotalMemory; |
| } |
| |
| synchronized void setTotalNativeMemory(int totalMemory) { |
| mNativeTotalMemory = totalMemory; |
| } |
| |
| synchronized void addNativeLibraryMapInfo(long startAddr, long endAddr, String library) { |
| mNativeLibMapInfo.add(new NativeLibraryMapInfo(startAddr, endAddr, library)); |
| } |
| |
| /** |
| * Returns the list of native libraries mapped in memory for this client. |
| */ |
| public synchronized List<NativeLibraryMapInfo> getMappedNativeLibraries() { |
| return Collections.unmodifiableList(mNativeLibMapInfo); |
| } |
| |
| synchronized void setAllocationStatus(AllocationTrackingStatus status) { |
| mAllocationStatus = status; |
| } |
| |
| /** |
| * Returns the allocation tracking status. |
| * @see Client#requestAllocationStatus() |
| */ |
| public synchronized AllocationTrackingStatus getAllocationStatus() { |
| return mAllocationStatus; |
| } |
| |
| synchronized void setAllocations(AllocationInfo[] allocs) { |
| mAllocations = allocs; |
| } |
| |
| /** |
| * Returns the list of tracked allocations. |
| * @see Client#requestAllocationDetails() |
| */ |
| @Nullable |
| public synchronized AllocationInfo[] getAllocations() { |
| return mAllocations; |
| } |
| |
| void addFeature(String feature) { |
| mFeatures.add(feature); |
| } |
| |
| /** |
| * Returns true if the {@link Client} supports the given <var>feature</var> |
| * @param feature The feature to test. |
| * @return true if the feature is supported |
| * |
| * @see ClientData#FEATURE_PROFILING |
| * @see ClientData#FEATURE_HPROF |
| */ |
| public boolean hasFeature(String feature) { |
| return mFeatures.contains(feature); |
| } |
| |
| /** |
| * Sets the device-side path to the hprof file being written |
| * @param pendingHprofDump the file to the hprof file |
| */ |
| @Deprecated |
| void setPendingHprofDump(String pendingHprofDump) { |
| mPendingHprofDump = pendingHprofDump; |
| } |
| |
| /** |
| * Returns the path to the device-side hprof file being written. |
| */ |
| @Deprecated |
| String getPendingHprofDump() { |
| return mPendingHprofDump; |
| } |
| |
| @Deprecated |
| public boolean hasPendingHprofDump() { |
| return mPendingHprofDump != null; |
| } |
| |
| synchronized void setMethodProfilingStatus(MethodProfilingStatus status) { |
| mProfilingStatus = status; |
| } |
| |
| /** |
| * Returns the method profiling status. |
| * @see Client#requestMethodProfilingStatus() |
| */ |
| public synchronized MethodProfilingStatus getMethodProfilingStatus() { |
| return mProfilingStatus; |
| } |
| |
| /** |
| * Sets the device-side path to the method profile file being written |
| * @param pendingMethodProfiling the file being written |
| */ |
| void setPendingMethodProfiling(String pendingMethodProfiling) { |
| mPendingMethodProfiling = pendingMethodProfiling; |
| } |
| |
| /** |
| * Returns the path to the device-side method profiling file being written. |
| */ |
| String getPendingMethodProfiling() { |
| return mPendingMethodProfiling; |
| } |
| } |
| |
