Home | History | Annotate | Download | only in item 
      1 /*
      2  * Copyright (C) 2015 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 package com.android.loganalysis.item;
     17 
     18 import org.json.JSONArray;
     19 import org.json.JSONException;
     20 import org.json.JSONObject;
     21 
     22 import java.util.Arrays;
     23 import java.util.Collection;
     24 import java.util.HashSet;
     25 import java.util.LinkedList;
     26 import java.util.List;
     27 import java.util.Set;
     28 
     29 /**
     30  * An {@link IItem} used to store information related to interrupts
     31  */
     32 public class InterruptItem implements IItem {
     33     /** Constant for JSON output */
     34     public static final String INTERRUPTS = "INTERRUPT_INFO";
     35 
     36     private Collection<InterruptInfoItem> mInterrupts = new LinkedList<InterruptInfoItem>();
     37 
     38     /**
     39      * Enum for describing the type of interrupt
     40      */
     41     public enum InterruptCategory {
     42         WIFI_INTERRUPT,
     43         MODEM_INTERRUPT,
     44         ALARM_INTERRUPT,
     45         ADSP_INTERRUPT,
     46         UNKNOWN_INTERRUPT,
     47     }
     48 
     49     public static class InterruptInfoItem extends GenericItem {
     50         /** Constant for JSON output */
     51         public static final String NAME = "NAME";
     52         /** Constant for JSON output */
     53         public static final String CATEGORY = "CATEGORY";
     54         /** Constant for JSON output */
     55         public static final String INTERRUPT_COUNT = "INTERRUPT_COUNT";
     56 
     57         private static final Set<String> ATTRIBUTES = new HashSet<String>(Arrays.asList(
     58                 NAME, INTERRUPT_COUNT, CATEGORY));
     59 
     60         /**
     61          * The constructor for {@link InterruptItem}
     62          *
     63          * @param name The name of the wake lock
     64          * @param interruptCount The number of times the interrupt woke up the AP
     65          * @param category The {@link InterruptCategory} of the interrupt
     66          */
     67         public InterruptInfoItem(String name, int interruptCount,
     68                 InterruptCategory category) {
     69             super(ATTRIBUTES);
     70 
     71             setAttribute(NAME, name);
     72             setAttribute(INTERRUPT_COUNT, interruptCount);
     73             setAttribute(CATEGORY, category);
     74         }
     75 
     76         /**
     77          * Get the name of the interrupt
     78          */
     79         public String getName() {
     80             return (String) getAttribute(NAME);
     81         }
     82 
     83         /**
     84          * Get the interrupt count.
     85          */
     86         public int getInterruptCount() {
     87             return (Integer) getAttribute(INTERRUPT_COUNT);
     88         }
     89 
     90         /**
     91          * Get the {@link InterruptCategory} of the wake lock.
     92          */
     93         public InterruptCategory getCategory() {
     94             return (InterruptCategory) getAttribute(CATEGORY);
     95         }
     96     }
     97 
     98     /**
     99      * Add an interrupt from the battery info section.
    100      *
    101      * @param name The name of the interrupt
    102      * @param interruptCount Number of interrupts
    103      * @param category The {@link InterruptCategory} of the interrupt.
    104      */
    105     public void addInterrupt(String name, int interruptCount,
    106             InterruptCategory category) {
    107         mInterrupts.add(new InterruptInfoItem(name, interruptCount, category));
    108     }
    109 
    110     /**
    111      * Get a list of {@link InterruptInfoItem} objects matching a given {@link InterruptCategory}.
    112      */
    113     public List<InterruptInfoItem> getInterrupts(InterruptCategory category) {
    114         LinkedList<InterruptInfoItem> interrupts = new LinkedList<InterruptInfoItem>();
    115         if (category == null) {
    116             return interrupts;
    117         }
    118 
    119         for (InterruptInfoItem interrupt : mInterrupts) {
    120             if (category.equals(interrupt.getCategory())) {
    121                 interrupts.add(interrupt);
    122             }
    123         }
    124         return interrupts;
    125     }
    126 
    127     /**
    128      * Get a list of {@link InterruptInfoItem} objects
    129      */
    130     public List<InterruptInfoItem> getInterrupts() {
    131         return (List<InterruptInfoItem>) mInterrupts;
    132     }
    133 
    134     /**
    135      * {@inheritDoc}
    136      */
    137     @Override
    138     public IItem merge(IItem other) throws ConflictingItemException {
    139         throw new ConflictingItemException("Wakelock items cannot be merged");
    140     }
    141 
    142     /**
    143      * {@inheritDoc}
    144      */
    145     @Override
    146     public boolean isConsistent(IItem other) {
    147         return false;
    148     }
    149 
    150     /**
    151      * {@inheritDoc}
    152      */
    153     @Override
    154     public JSONObject toJson() {
    155         JSONObject object = new JSONObject();
    156         if (mInterrupts != null) {
    157             try {
    158                 JSONArray interrupts = new JSONArray();
    159                 for (InterruptInfoItem interrupt : mInterrupts) {
    160                     interrupts.put(interrupt.toJson());
    161                 }
    162                 object.put(INTERRUPTS, interrupts);
    163             } catch (JSONException e) {
    164                 // Ignore
    165             }
    166         }
    167         return object;
    168     }
    169 }
    170