diff --git a/core/api/src/main/java/org/onosproject/net/flow/DefaultFlowEntry.java b/core/api/src/main/java/org/onosproject/net/flow/DefaultFlowEntry.java
index a770e97..943ad84 100644
--- a/core/api/src/main/java/org/onosproject/net/flow/DefaultFlowEntry.java
+++ b/core/api/src/main/java/org/onosproject/net/flow/DefaultFlowEntry.java
@@ -29,31 +29,85 @@
 
     private static final Logger log = getLogger(DefaultFlowEntry.class);
 
+    private static final long DEFAULT_LAST_SEEN = -1;
+    private static final int DEFAULT_ERR_CODE = -1;
+    private static final int DEFAULT_ERR_TYPE = -1;
+
     /* Stored in nanoseconds (allows for 292 years) */
     private long life;
 
     private long packets;
     private long bytes;
     private FlowEntryState state;
+    private FlowLiveType liveType;
 
-    private long lastSeen = -1;
+    private long lastSeen = DEFAULT_LAST_SEEN;
 
     private final int errType;
 
     private final int errCode;
 
+    /**
+     * Creates a flow entry of flow table specified with the flow rule, state
+     * and statistic information.
+     *
+     * @param rule the flow rule
+     * @param state the flow state
+     * @param life the duration second of flow
+     * @param lifeTimeUnit life time unit
+     * @param packets the number of packets of this flow
+     * @param bytes the the number of bytes of this flow
+     */
     public DefaultFlowEntry(FlowRule rule, FlowEntryState state,
                             long life, TimeUnit lifeTimeUnit, long packets, long bytes) {
         super(rule);
         this.state = state;
         this.life = lifeTimeUnit.toNanos(life);
+        this.liveType = FlowLiveType.UNKNOWN;
         this.packets = packets;
         this.bytes = bytes;
-        this.errCode = -1;
-        this.errType = -1;
+        this.errCode = DEFAULT_ERR_CODE;
+        this.errType = DEFAULT_ERR_TYPE;
         this.lastSeen = System.currentTimeMillis();
     }
 
+    /**
+     * Creates a flow entry of flow table specified with the flow rule, state
+     * and statistic information.
+     *
+     * @param rule the flow rule
+     * @param state the flow state
+     * @param life the duration second of flow
+     * @param lifeTimeUnit life time unit
+     * @param liveType the flow live type, i.e., IMMEDIATE, SHORT, MID, LONG
+     * @param packets the number of packets of this flow
+     * @param bytes the the number of bytes of this flow
+     */
+    public DefaultFlowEntry(FlowRule rule, FlowEntryState state,
+                            long life, TimeUnit lifeTimeUnit, FlowLiveType liveType,
+                            long packets, long bytes) {
+        this(rule, state, life, lifeTimeUnit, packets, bytes);
+        this.liveType = liveType;
+    }
+
+    /**
+     * Creates a flow entry of flow table specified with the flow rule, state,
+     * live type and statistic information.
+     *
+     * @param rule the flow rule
+     * @param state the flow state
+     * @param lifeSecs the duration second of flow
+     * @param liveType the flow live type, i.e., IMMEDIATE, SHORT, MID, LONG
+     * @param packets the number of packets of this flow
+     * @param bytes the the number of bytes of this flow
+     */
+    public DefaultFlowEntry(FlowRule rule, FlowEntryState state,
+                            long lifeSecs, FlowLiveType liveType,
+                            long packets, long bytes) {
+        this(rule, state, lifeSecs, SECONDS, packets, bytes);
+        this.liveType = liveType;
+    }
+
     public DefaultFlowEntry(FlowRule rule, FlowEntryState state,
                             long lifeSecs, long packets, long bytes) {
         this(rule, state, lifeSecs, SECONDS, packets, bytes);
@@ -63,6 +117,14 @@
         this(rule, FlowEntryState.PENDING_ADD, 0, 0, 0);
     }
 
+    /**
+     * Creates a flow entry of flow table specified with the flow rule, state,
+     * live type and statistic information.
+     *
+     * @param rule the flow rule
+     * @param errType the error type
+     * @param errCode the error code
+     */
     public DefaultFlowEntry(FlowRule rule, int errType, int errCode) {
         super(rule);
         this.state = FlowEntryState.FAILED;
@@ -82,6 +144,11 @@
     }
 
     @Override
+    public FlowLiveType liveType() {
+        return liveType;
+    }
+
+    @Override
     public long packets() {
         return packets;
     }
@@ -122,6 +189,11 @@
     }
 
     @Override
+    public void setLiveType(FlowLiveType liveType) {
+        this.liveType = liveType;
+    }
+
+    @Override
     public void setPackets(long packets) {
         this.packets = packets;
     }
@@ -146,6 +218,13 @@
         return toStringHelper(this)
                 .add("rule", super.toString())
                 .add("state", state)
+                .add("life", life)
+                .add("liveType", liveType)
+                .add("packets", packets)
+                .add("bytes", bytes)
+                .add("errCode", errCode)
+                .add("errType", errType)
+                .add("lastSeen", lastSeen)
                 .toString();
     }
 }
diff --git a/core/api/src/main/java/org/onosproject/net/flow/DefaultTypedFlowEntry.java b/core/api/src/main/java/org/onosproject/net/flow/DefaultTypedFlowEntry.java
index 31d394a..80b7854 100644
--- a/core/api/src/main/java/org/onosproject/net/flow/DefaultTypedFlowEntry.java
+++ b/core/api/src/main/java/org/onosproject/net/flow/DefaultTypedFlowEntry.java
@@ -26,7 +26,7 @@
  */
 public class DefaultTypedFlowEntry extends DefaultFlowEntry
     implements TypedStoredFlowEntry {
-    private FlowLiveType liveType;
+    private TypedStoredFlowEntry.FlowLiveType liveType;
 
 
     /**
@@ -42,7 +42,7 @@
     public DefaultTypedFlowEntry(FlowRule rule, FlowEntryState state,
                                  long life, TimeUnit lifeTimeUnit, long packets, long bytes) {
         super(rule, state, life, lifeTimeUnit, packets, bytes);
-        this.liveType = FlowLiveType.IMMEDIATE_FLOW;
+        this.liveType = TypedStoredFlowEntry.FlowLiveType.IMMEDIATE_FLOW;
     }
 
     /**
@@ -58,7 +58,7 @@
     public DefaultTypedFlowEntry(FlowRule rule, FlowEntryState state,
                             long life, long packets, long bytes) {
         super(rule, state, life, packets, bytes);
-        this.liveType = FlowLiveType.IMMEDIATE_FLOW;
+        this.liveType = TypedStoredFlowEntry.FlowLiveType.IMMEDIATE_FLOW;
     }
 
     /**
@@ -69,7 +69,7 @@
      */
     public DefaultTypedFlowEntry(FlowRule rule) {
         super(rule);
-        this.liveType = FlowLiveType.IMMEDIATE_FLOW;
+        this.liveType = TypedStoredFlowEntry.FlowLiveType.IMMEDIATE_FLOW;
     }
 
     /**
@@ -80,7 +80,7 @@
      */
     public DefaultTypedFlowEntry(FlowEntry fe) {
         super(fe, fe.state(), fe.life(NANOSECONDS), NANOSECONDS, fe.packets(), fe.bytes());
-        this.liveType = FlowLiveType.IMMEDIATE_FLOW;
+        this.liveType = TypedStoredFlowEntry.FlowLiveType.IMMEDIATE_FLOW;
     }
 
     /**
@@ -90,7 +90,7 @@
      * @param liveType the flow live type
      *
      */
-    public DefaultTypedFlowEntry(FlowRule rule, FlowLiveType liveType) {
+    public DefaultTypedFlowEntry(FlowRule rule, TypedStoredFlowEntry.FlowLiveType liveType) {
         super(rule);
         this.liveType = liveType;
     }
@@ -102,7 +102,7 @@
      * @param liveType the flow live type
      *
      */
-    public DefaultTypedFlowEntry(FlowEntry fe,  FlowLiveType liveType) {
+    public DefaultTypedFlowEntry(FlowEntry fe,  TypedStoredFlowEntry.FlowLiveType liveType) {
         super(fe, fe.state(), fe.life(NANOSECONDS), NANOSECONDS, fe.packets(), fe.bytes());
         this.liveType = liveType;
     }
@@ -116,18 +116,19 @@
      * @param liveType the flow live type
      *
      */
-    public DefaultTypedFlowEntry(FlowRule rule, int errType, int errCode, FlowLiveType liveType) {
+    public DefaultTypedFlowEntry(FlowRule rule, int errType, int errCode,
+                                    TypedStoredFlowEntry.FlowLiveType liveType) {
         super(rule, errType, errCode);
         this.liveType = liveType;
     }
 
     @Override
-    public FlowLiveType flowLiveType() {
+    public TypedStoredFlowEntry.FlowLiveType flowLiveType() {
         return this.liveType;
     }
 
     @Override
-    public void setFlowLiveType(FlowLiveType liveType) {
+    public void setFlowLiveType(TypedStoredFlowEntry.FlowLiveType liveType) {
         this.liveType = liveType;
     }
 
diff --git a/core/api/src/main/java/org/onosproject/net/flow/FlowEntry.java b/core/api/src/main/java/org/onosproject/net/flow/FlowEntry.java
index a235786..f0d8098 100644
--- a/core/api/src/main/java/org/onosproject/net/flow/FlowEntry.java
+++ b/core/api/src/main/java/org/onosproject/net/flow/FlowEntry.java
@@ -68,6 +68,46 @@
      */
     long life();
 
+    enum FlowLiveType {
+
+        /**
+         * Indicates that this rule has been submitted for addition immediately.
+         * Not necessarily collecting flow stats.
+         */
+        IMMEDIATE,
+
+        /**
+         * Indicates that this rule has been submitted for a short time.
+         * Collecting flow stats every SHORT interval, defined by the implementation.
+         */
+        SHORT,
+
+        /**
+         * Indicates that this rule has been submitted for a mid time.
+         * Collecting flow stats every MID interval, defined by the implementation.
+         */
+        MID,
+
+        /**
+         * Indicates that this rule has been submitted for a long time.
+         * Collecting flow stats every LONG interval, defined by the implementation.
+         */
+        LONG,
+
+        /**
+         * Indicates that this rule has been submitted for UNKNOWN or ERROR.
+         * Not necessarily collecting flow stats.
+         */
+        UNKNOWN
+    }
+
+    /**
+     * Gets the flow live type for this entry.
+     *
+     * @return flow live type
+     */
+    FlowLiveType liveType();
+
     /**
      * Returns the time this flow rule has been applied.
      *
diff --git a/core/api/src/main/java/org/onosproject/net/flow/FlowRuleService.java b/core/api/src/main/java/org/onosproject/net/flow/FlowRuleService.java
index 62e725e..37a7c54 100644
--- a/core/api/src/main/java/org/onosproject/net/flow/FlowRuleService.java
+++ b/core/api/src/main/java/org/onosproject/net/flow/FlowRuleService.java
@@ -15,6 +15,7 @@
  */
 package org.onosproject.net.flow;
 
+import com.google.common.collect.Iterables;
 import org.onosproject.core.ApplicationId;
 import org.onosproject.event.ListenerService;
 import org.onosproject.net.DeviceId;
@@ -52,6 +53,20 @@
     Iterable<FlowEntry> getFlowEntries(DeviceId deviceId);
 
     /**
+     * Returns a list of rules filtered by device id and flow live type.
+     *
+     * @param deviceId the device id to lookup
+     * @param liveType the flow live type to lookup
+     * @return collection of flow entries
+     */
+    default Iterable<FlowEntry> getFlowEntriesByLiveType(DeviceId deviceId,
+                                                 FlowEntry.FlowLiveType liveType) {
+        return Iterables.filter(getFlowEntries(deviceId), fe -> fe.liveType() == liveType);
+    }
+
+    // TODO: add createFlowRule factory method and execute operations method
+
+    /**
      * Applies the specified flow rules onto their respective devices. These
      * flow rules will be retained by the system and re-applied anytime the
      * device reconnects to the controller.
diff --git a/core/api/src/main/java/org/onosproject/net/flow/StoredFlowEntry.java b/core/api/src/main/java/org/onosproject/net/flow/StoredFlowEntry.java
index b3a6564..e94e6de 100644
--- a/core/api/src/main/java/org/onosproject/net/flow/StoredFlowEntry.java
+++ b/core/api/src/main/java/org/onosproject/net/flow/StoredFlowEntry.java
@@ -45,6 +45,13 @@
     void setLife(long life, TimeUnit timeUnit);
 
     /**
+     * Sets the flow live type,
+     * i.e., IMMEDIATE, SHORT, MID, LONG.
+     * @param liveType flow live type
+     */
+    void setLiveType(FlowLiveType liveType);
+
+    /**
      * Number of packets seen by this entry.
      * @param packets a long value
      */
diff --git a/core/api/src/main/java/org/onosproject/net/flow/TypedStoredFlowEntry.java b/core/api/src/main/java/org/onosproject/net/flow/TypedStoredFlowEntry.java
index 92fdf7e..8b8554a 100644
--- a/core/api/src/main/java/org/onosproject/net/flow/TypedStoredFlowEntry.java
+++ b/core/api/src/main/java/org/onosproject/net/flow/TypedStoredFlowEntry.java
@@ -57,11 +57,11 @@
      *
      * @return flow live type
      */
-    FlowLiveType flowLiveType();
+    TypedStoredFlowEntry.FlowLiveType flowLiveType();
 
     /**
      * Sets the new flow live type for this entry.
      * @param liveType new flow live type.
      */
-    void setFlowLiveType(FlowLiveType liveType);
+    void setFlowLiveType(TypedStoredFlowEntry.FlowLiveType liveType);
 }
diff --git a/core/api/src/main/java/org/onosproject/net/statistic/DefaultLoad.java b/core/api/src/main/java/org/onosproject/net/statistic/DefaultLoad.java
index 1755136..add3a76 100644
--- a/core/api/src/main/java/org/onosproject/net/statistic/DefaultLoad.java
+++ b/core/api/src/main/java/org/onosproject/net/statistic/DefaultLoad.java
@@ -33,7 +33,7 @@
     /**
      * Indicates the flow statistics poll interval in seconds.
      */
-    private static long pollInterval = 10;
+    private static long pollInterval = 10; // same as IMMEDIATE and SHORT flow live type
 
     /**
      * Creates an invalid load.
diff --git a/core/api/src/main/java/org/onosproject/net/statistic/FlowEntryWithLoad.java b/core/api/src/main/java/org/onosproject/net/statistic/FlowEntryWithLoad.java
new file mode 100644
index 0000000..a5e85b2
--- /dev/null
+++ b/core/api/src/main/java/org/onosproject/net/statistic/FlowEntryWithLoad.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright 2014-present Open Networking Laboratory
+ *
+ * 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 org.onosproject.net.statistic;
+
+import org.onosproject.net.ConnectPoint;
+import org.onosproject.net.flow.FlowEntry;
+import org.onosproject.net.flow.StoredFlowEntry;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * Load of flow entry with flow live type.
+ */
+public class FlowEntryWithLoad {
+    private final ConnectPoint cp;
+    private final FlowEntry fe;
+    private final Load load;
+
+    /**
+     * Creates a new flow entry with load.
+     *
+     * @param cp connect point
+     * @param fe flow entry with live type
+     * @param load load
+     */
+    public FlowEntryWithLoad(ConnectPoint cp, FlowEntry fe, Load load) {
+        checkArgument(fe instanceof StoredFlowEntry, "FlowEntry must be StoredFlowEntry class type");
+        this.cp = cp;
+        this.fe = fe;
+        this.load = load;
+    }
+
+    /**
+     * Creates a new flow entry with load.
+     *
+     * @param cp connect point
+     * @param fe flow entry with live type
+     */
+    public FlowEntryWithLoad(ConnectPoint cp, FlowEntry fe) {
+        checkArgument(fe instanceof StoredFlowEntry, "FlowEntry must be StoredFlowEntry class type");
+        this.cp = cp;
+        this.fe = fe;
+        this.load = new DefaultLoad(fe.bytes(), 0, typedPollInterval(fe));
+    }
+
+    /**
+     * Returns connect point.
+     *
+     * @return connect point
+     */
+    public ConnectPoint connectPoint() {
+        return cp;
+    }
+
+    /**
+     * Returns stored flow entry.
+     *
+     * @return flow entry
+     */
+    public StoredFlowEntry storedFlowEntry() {
+        return (StoredFlowEntry) fe;
+    }
+
+    /**
+     * Returns current load.
+     *
+     * @return load
+     */
+    public Load load() {
+        return load;
+    }
+
+    /**
+     * Returns current flow entry's polling interval.
+     *
+     * @param fe flow entry
+     * @return poll interval time unit in seconds
+     */
+    private long typedPollInterval(FlowEntry fe) {
+        checkNotNull(fe, "FlowEntry cannot be null");
+
+        PollInterval pollIntervalInstance = PollInterval.getInstance();
+
+        switch (fe.liveType()) {
+            case LONG:
+                return pollIntervalInstance.getLongPollInterval();
+            case MID:
+                return pollIntervalInstance.getMidPollInterval();
+            case SHORT:
+            case IMMEDIATE:
+            case UNKNOWN:
+            default:
+                return pollIntervalInstance.getPollInterval();
+        }
+    }
+}
diff --git a/core/api/src/main/java/org/onosproject/net/statistic/FlowStatisticService.java b/core/api/src/main/java/org/onosproject/net/statistic/FlowStatisticService.java
index e55237e..926b291 100644
--- a/core/api/src/main/java/org/onosproject/net/statistic/FlowStatisticService.java
+++ b/core/api/src/main/java/org/onosproject/net/statistic/FlowStatisticService.java
@@ -19,6 +19,7 @@
 import org.onosproject.net.ConnectPoint;
 import org.onosproject.net.Device;
 import org.onosproject.net.PortNumber;
+import org.onosproject.net.flow.FlowEntry;
 import org.onosproject.net.flow.TypedStoredFlowEntry;
 import org.onosproject.net.flow.instructions.Instruction;
 
@@ -56,6 +57,66 @@
      * @param instType the InstructionType to filter, null means no filtering.
      * @return map of flow entry load
      */
+    Map<ConnectPoint, List<FlowEntryWithLoad>> loadAllByType(Device device,
+                                                             FlowEntry.FlowLiveType liveType,
+                                                             Instruction.Type instType);
+
+    /**
+     * Obtain the flow type and load list for the device with the given link or port.
+     *
+     * @param device the Device to query.
+     * @param pNumber the port number of the Device to query
+     * @param liveType the FlowLiveType  to filter, null means no filtering .
+     * @param instType the InstructionType to filter, null means no filtering.
+     * @return list of flow entry load
+     */
+    List<FlowEntryWithLoad> loadAllByType(Device device,
+                                          PortNumber pNumber,
+                                          FlowEntry.FlowLiveType liveType,
+                                          Instruction.Type instType);
+
+    /**
+     * Obtain the set of the flow type and load topn list for the device with the given link.
+     *
+     * @param device the Device  to query.
+     * @param liveType the FlowLiveType  to filter, null means no filtering .
+     * @param instType the InstructionType to filter, null means no filtering.
+     * @param topn the top number to filter, null means no filtering.
+     * @return map of flow entry load
+     */
+    Map<ConnectPoint, List<FlowEntryWithLoad>> loadTopnByType(Device device,
+                                                              FlowEntry.FlowLiveType liveType,
+                                                              Instruction.Type instType,
+                                                              int topn);
+
+    /**
+     * Obtain the flow type and load topn list for the device with the given link or port.
+     *
+     * @param device the Device  to query.
+     * @param pNumber the port number of the Device to query
+     * @param liveType the FlowLiveType  to filter, null means no filtering .
+     * @param instType the InstructionType to filter, null means no filtering.
+     * @param topn the top n list entry
+     * @return list of flow entry load
+     */
+    List<FlowEntryWithLoad> loadTopnByType(Device device,
+                                           PortNumber pNumber,
+                                           FlowEntry.FlowLiveType liveType,
+                                           Instruction.Type instType,
+                                           int topn);
+
+    // The belows are deprecated interfaces...
+
+    /**
+     * Obtain the set of the flow type and load list for the device with the given link.
+     *
+     * @param device the Device  to query.
+     * @param liveType the FlowLiveType  to filter, null means no filtering .
+     * @param instType the InstructionType to filter, null means no filtering.
+     * @return map of flow entry load
+     * @deprecated in Ibis(1.8.1) release
+     */
+    @Deprecated
     Map<ConnectPoint, List<TypedFlowEntryWithLoad>> loadAllByType(Device device,
                                                                   TypedStoredFlowEntry.FlowLiveType liveType,
                                                                   Instruction.Type instType);
@@ -68,8 +129,11 @@
      * @param liveType the FlowLiveType  to filter, null means no filtering .
      * @param instType the InstructionType to filter, null means no filtering.
      * @return list of flow entry load
+     * @deprecated in Ibis(1.8.1) release
      */
-    List<TypedFlowEntryWithLoad> loadAllByType(Device device, PortNumber pNumber,
+    @Deprecated
+    List<TypedFlowEntryWithLoad> loadAllByType(Device device,
+                                               PortNumber pNumber,
                                                TypedStoredFlowEntry.FlowLiveType liveType,
                                                Instruction.Type instType);
 
@@ -81,7 +145,9 @@
      * @param instType the InstructionType to filter, null means no filtering.
      * @param topn the top number to filter, null means no filtering.
      * @return map of flow entry load
+     * @deprecated in Ibis(1.8.1) release
      */
+    @Deprecated
     Map<ConnectPoint, List<TypedFlowEntryWithLoad>> loadTopnByType(Device device,
                                                                    TypedStoredFlowEntry.FlowLiveType liveType,
                                                                    Instruction.Type instType,
@@ -96,8 +162,11 @@
      * @param instType the InstructionType to filter, null means no filtering.
      * @param topn topn //FIXME what?
      * @return list of flow entry load
+     * @deprecated in Ibis(1.8.1) release
      */
-    List<TypedFlowEntryWithLoad> loadTopnByType(Device device, PortNumber pNumber,
+    @Deprecated
+    List<TypedFlowEntryWithLoad> loadTopnByType(Device device,
+                                                PortNumber pNumber,
                                                 TypedStoredFlowEntry.FlowLiveType liveType,
                                                 Instruction.Type instType,
                                                 int topn);
diff --git a/core/api/src/main/java/org/onosproject/net/statistic/PollInterval.java b/core/api/src/main/java/org/onosproject/net/statistic/PollInterval.java
new file mode 100644
index 0000000..ca19b58
--- /dev/null
+++ b/core/api/src/main/java/org/onosproject/net/statistic/PollInterval.java
@@ -0,0 +1,186 @@
+/*
+ * Copyright 2014-2016 Open Networking Laboratory
+ *
+ * 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 org.onosproject.net.statistic;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+/**
+ * Default polling interval values.
+ */
+public final class PollInterval {
+    private static final long DEFAULT_POLL_INTERVAL = 10;
+    private static final long DEFAULT_MID_POLL_INTERVAL = 20;
+    private static final long DEFAULT_LONG_POLL_INTERVAL = 30;
+    private static final long DEFAULT_ENTIRE_POLL_INTERVAL = 60;
+
+    private static PollInterval pollIntervalInstance =
+            new PollInterval(DEFAULT_POLL_INTERVAL,
+                             DEFAULT_MID_POLL_INTERVAL,
+                             DEFAULT_LONG_POLL_INTERVAL,
+                             DEFAULT_ENTIRE_POLL_INTERVAL);
+
+    /**
+     * Indicates the flow statistics poll interval in seconds.
+     */
+    private long pollInterval = DEFAULT_POLL_INTERVAL;
+    // same as IMMEDIATE and SHORT flow live type
+
+    // These may be used in NewFlowStatsCollector
+    private long midPollInterval = DEFAULT_MID_POLL_INTERVAL; // default is 2*pollInterval
+    private long longPollInterval = DEFAULT_LONG_POLL_INTERVAL; // default is 3*pollInterval
+    private long entirePollInterval = DEFAULT_ENTIRE_POLL_INTERVAL; // default is 6*pollInterval
+
+    /**
+     * Returns the singleton PollInterval instance class for FlowStatisticService and other statistic services.
+     * This instance is only used Adaptive Flow Sampling(adaptiveFlowSampling) mode is enabled(true).
+     *
+     * @return the singleton PollInterval instance class
+     */
+    public static PollInterval getInstance() {
+        return pollIntervalInstance;
+    }
+
+    /**
+     * Creates an default poll interval.
+     */
+    protected PollInterval() {
+        this.pollInterval = DEFAULT_POLL_INTERVAL;
+        this.midPollInterval = DEFAULT_MID_POLL_INTERVAL;
+        this.longPollInterval = DEFAULT_LONG_POLL_INTERVAL;
+        this.entirePollInterval = DEFAULT_ENTIRE_POLL_INTERVAL;
+    }
+
+    // Public construction is prohibited
+    /**
+     * Creates a poll interval from the parameters.
+     *
+     * @param pollInterval  the poll interval value
+     * @param midPollInterval the mid poll interval value
+     * @param longPollInterval the long poll interval value
+     * @param entirePollInterval the entire poll interval value
+     */
+    private PollInterval(long pollInterval, long midPollInterval,
+                               long longPollInterval, long entirePollInterval) {
+        checkArgument(pollInterval > 0, "Poll interval must be greater than 0");
+        checkArgument(midPollInterval > 0 && midPollInterval > pollInterval,
+                      "Mid poll interval must be greater than 0 and pollInterval");
+        checkArgument(longPollInterval > 0 && longPollInterval > midPollInterval,
+                      "Long poll interval must be greater than 0 and midPollInterval");
+        checkArgument(entirePollInterval > 0 && entirePollInterval > longPollInterval,
+                      "Entire poll interval must be greater than 0 and longPollInterval");
+
+        this.pollInterval = pollInterval;
+        this.midPollInterval = midPollInterval;
+        this.longPollInterval = longPollInterval;
+        this.entirePollInterval = entirePollInterval;
+    }
+
+    /**
+     * Sets the poll interval in seconds. Used solely for the purpose of
+     * computing the load.
+     *
+     * @param newPollInterval poll interval duration in seconds
+     */
+    public void setPollInterval(long newPollInterval) {
+        checkArgument(newPollInterval > 0, "Poll interval must be greater than 0");
+
+        pollInterval = newPollInterval;
+    }
+
+    /**
+     * Sets the mid poll interval in seconds. Used solely for the purpose of
+     * computing the load.
+     *
+     * @param newPollInterval poll interval duration in seconds
+     */
+    public void setMidPollInterval(long newPollInterval) {
+        checkArgument(newPollInterval > 0 && newPollInterval > pollInterval,
+                      "Mid poll interval must be greater than 0 and pollInterval");
+
+        midPollInterval = newPollInterval;
+    }
+
+    /**
+     * Sets the long poll interval in seconds. Used solely for the purpose of
+     * computing the load.
+     *
+     * @param newPollInterval poll interval duration in seconds
+     */
+    public void setLongPollInterval(long newPollInterval) {
+        checkArgument(newPollInterval > 0 && newPollInterval > midPollInterval,
+                      "Long poll interval must be greater than 0 and midPollInterval");
+
+        longPollInterval = newPollInterval;
+    }
+
+    /**
+     * Sets the entire poll interval in seconds. Used solely for the purpose of
+     * computing the load.
+     *
+     * @param newPollInterval poll interval duration in seconds
+     */
+    public void setEntirePollInterval(long newPollInterval) {
+        checkArgument(newPollInterval > 0 && newPollInterval > longPollInterval,
+                      "Entire poll interval must be greater than 0 and longPollInterval");
+
+        entirePollInterval = newPollInterval;
+    }
+
+    /**
+     * Returns default poll interval value in seconds.
+     *
+     * @return default poll interval
+     */
+    public long getPollInterval() {
+        return pollInterval;
+    }
+
+    /**
+     * Returns mid poll interval value in seconds.
+     *
+     * @return mid poll interval
+     */
+    public long getMidPollInterval() {
+        return midPollInterval;
+    }
+
+    /**
+     * Returns long poll interval value in seconds.
+     *
+     * @return long poll interval
+     */
+    public long getLongPollInterval() {
+        return longPollInterval;
+    }
+
+    /**
+     * Returns entire poll interval value in seconds.
+     *
+     * @return entire poll interval
+     */
+    public long getEntirePollInterval() {
+        return entirePollInterval;
+    }
+
+    /**
+     * Returns average poll interval value in seconds.
+     *
+     * @return average poll interval
+     */
+    public long getAvgPollInterval() {
+        return (pollInterval + midPollInterval + longPollInterval) / 3;
+    }
+}
diff --git a/core/api/src/main/java/org/onosproject/net/statistic/TypedFlowEntryWithLoad.java b/core/api/src/main/java/org/onosproject/net/statistic/TypedFlowEntryWithLoad.java
index 15c4d33..04d78ae 100644
--- a/core/api/src/main/java/org/onosproject/net/statistic/TypedFlowEntryWithLoad.java
+++ b/core/api/src/main/java/org/onosproject/net/statistic/TypedFlowEntryWithLoad.java
@@ -27,14 +27,9 @@
  * Load of flow entry of flow live type.
  */
 public class TypedFlowEntryWithLoad {
-    private ConnectPoint cp;
-    private TypedStoredFlowEntry tfe;
-    private Load load;
-
-    //TODO: make this variables class, and share with NewAdaptivceFlowStatsCollector class
-    private static final int CAL_AND_POLL_INTERVAL = 5; // means SHORT_POLL_INTERVAL
-    private static final int MID_POLL_INTERVAL = 10;
-    private static final int LONG_POLL_INTERVAL = 15;
+    private final ConnectPoint cp;
+    private final TypedStoredFlowEntry tfe;
+    private final Load load;
 
     /**
      * Creates a new typed flow entry with load.
@@ -82,45 +77,6 @@
     public Load load() {
         return load;
     }
-    public void setLoad(Load load) {
-        this.load = load;
-    }
-
-    /**
-     * Returns short polling interval.
-     *
-     * @return short poll interval
-     */
-    public static int shortPollInterval() {
-        return CAL_AND_POLL_INTERVAL;
-    }
-
-    /**
-     * Returns mid polling interval.
-     *
-     * @return mid poll interval
-     */
-    public static int midPollInterval() {
-        return MID_POLL_INTERVAL;
-    }
-
-    /**
-     * Returns long polling interval.
-     *
-     * @return long poll interval
-     */
-    public static int longPollInterval() {
-        return LONG_POLL_INTERVAL;
-    }
-
-    /**
-     * Returns average polling interval.
-     *
-     * @return average poll interval
-     */
-    public static int avgPollInterval() {
-        return (CAL_AND_POLL_INTERVAL + MID_POLL_INTERVAL + LONG_POLL_INTERVAL) / 3;
-    }
 
     /**
      * Returns current typed flow entry's polling interval.
@@ -131,15 +87,17 @@
     public static long typedPollInterval(TypedStoredFlowEntry tfe) {
         checkNotNull(tfe, "TypedStoredFlowEntry cannot be null");
 
+        PollInterval pollIntervalInstance = PollInterval.getInstance();
+
         switch (tfe.flowLiveType()) {
             case LONG_FLOW:
-                return LONG_POLL_INTERVAL;
+                return pollIntervalInstance.getLongPollInterval();
             case MID_FLOW:
-                return MID_POLL_INTERVAL;
+                return pollIntervalInstance.getMidPollInterval();
             case SHORT_FLOW:
             case IMMEDIATE_FLOW:
             default:
-                return CAL_AND_POLL_INTERVAL;
+                return pollIntervalInstance.getPollInterval();
         }
     }
 
@@ -155,17 +113,18 @@
         }
 
         long life = fe.life();
+        PollInterval pollIntervalInstance = PollInterval.getInstance();
 
-        if (life >= LONG_POLL_INTERVAL) {
-            return new DefaultTypedFlowEntry(fe, TypedStoredFlowEntry.FlowLiveType.LONG_FLOW);
-        } else if (life >= MID_POLL_INTERVAL) {
-            return new DefaultTypedFlowEntry(fe, TypedStoredFlowEntry.FlowLiveType.MID_FLOW);
-        } else if (life >= CAL_AND_POLL_INTERVAL) {
-            return new DefaultTypedFlowEntry(fe, TypedStoredFlowEntry.FlowLiveType.SHORT_FLOW);
-        } else if (life >= 0) {
-            return new DefaultTypedFlowEntry(fe, TypedStoredFlowEntry.FlowLiveType.IMMEDIATE_FLOW);
-        } else { // life < 0
+        if (life < 0) {
             return new DefaultTypedFlowEntry(fe, TypedStoredFlowEntry.FlowLiveType.UNKNOWN_FLOW);
+        } else if (life < pollIntervalInstance.getPollInterval()) {
+            return new DefaultTypedFlowEntry(fe, TypedStoredFlowEntry.FlowLiveType.IMMEDIATE_FLOW);
+        } else if (life < pollIntervalInstance.getMidPollInterval()) {
+            return new DefaultTypedFlowEntry(fe, TypedStoredFlowEntry.FlowLiveType.SHORT_FLOW);
+        } else if (life < pollIntervalInstance.getLongPollInterval()) {
+            return new DefaultTypedFlowEntry(fe, TypedStoredFlowEntry.FlowLiveType.MID_FLOW);
+        } else { // >= longPollInterval
+            return new DefaultTypedFlowEntry(fe, TypedStoredFlowEntry.FlowLiveType.LONG_FLOW);
         }
     }
 }