path: root/ituxd/src/com/intel/thermal/ThermalService.java

/*
 * Copyright 2014 Intel Corporation All Rights Reserved.
 *
 * 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.intel.thermal;

import android.app.ActivityManagerNative;
import android.app.IntentService;
import android.app.Service;
import android.content.BroadcastReceiver;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.PackageManager;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import android.os.Message;
import android.os.Process;
import android.os.SystemProperties;
import android.os.UserHandle;
import android.util.Log;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.lang.ClassLoader;
import java.lang.NullPointerException;
import java.lang.reflect.Array;
import java.lang.SecurityException;
import java.util.ArrayList;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.Iterator;
import java.util.Map;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.XmlPullParserFactory;

/**
 * The ThermalService monitors the Thermal zones on the platform.
 * The number of thermal zones and sensors associated with the zones are
 * obtained from the thermal_sensor_config.xml file. When any thermal zone
 * crosses the thresholds configured in the xml, a Thermal Intent is sent.
 * ACTION_THERMAL_ZONE_STATE_CHANGED
 * The Thermal Cooling Manager acts upon this intent and throttles
 * the corresponding cooling device.
 *
 * @hide
 */
public class ThermalService extends Service {
    private static final String TAG = ThermalService.class.getSimpleName();
    private static Context mContext;
    private Handler mHandler = new Handler();
    static {
        System.loadLibrary("thermalJNI");
    }
    protected enum MetaTag {
            ENUM_UNKNOWN,
            ENUM_ZONETHRESHOLD,
            ENUM_POLLDELAY,
            ENUM_MOVINGAVGWINDOW
    }

    public class ThermalParser {
        // Names of the XML Tags
        private static final String PINFO = "PlatformInfo";
        private static final String SENSOR_ATTRIB = "SensorAttrib";
        private static final String SENSOR = "Sensor";
        private static final String ZONE = "Zone";
        private static final String THERMAL_CONFIG = "thermalconfig";
        private static final String THRESHOLD = "Threshold";
        private static final String POLLDELAY = "PollDelay";
        private static final String MOVINGAVGWINDOW = "MovingAverageWindow";
        private static final String ZONELOGIC = "ZoneLogic";
        private static final String WEIGHT = "Weight";
        private static final String ORDER = "Order";
        private static final String OFFSET = "Offset";
        private static final String ZONETHRESHOLD = "ZoneThreshold";
        private static final String PROFILE = "Profile";

        private boolean mDone = false;
        private ThermalManager.PlatformInfo mPlatformInfo = null;
        private ThermalSensor mCurrSensor = null;
        private ThermalZone mCurrZone = null;
        private ArrayList<ThermalSensorAttrib> mCurrSensorAttribList = null;
        private ThermalSensorAttrib mCurrSensorAttrib = null;
        private ArrayList<ThermalZone> mThermalZones = null;
        private ArrayList<Integer> mPollDelayList = null;
        private ArrayList<Integer> mMovingAvgWindowList = null;
        private ArrayList<Integer> mWeightList = null;
        private ArrayList<Integer> mOrderList = null;
        private ArrayList<Integer> mZoneThresholdList = null;
        private String mSensorName = null;
        XmlPullParserFactory mFactory = null;
        XmlPullParser mParser = null;
        int mTempZoneId = -1;
        int mNumProfiles = 0;
        String mTempZoneName = null;
        String mCurProfileName = ThermalManager.DEFAULT_PROFILE_NAME;
        FileReader mInputStream = null;

        ThermalParser(String fname) {
            try {
                mFactory = XmlPullParserFactory.newInstance(System.
                        getProperty(XmlPullParserFactory.PROPERTY_NAME), null);
                mFactory.setNamespaceAware(true);
                mParser = mFactory.newPullParser();
            } catch (SecurityException e) {
                Log.e(TAG, "SecurityException caught in ThermalParser");
            } catch (IllegalArgumentException e) {
                Log.e(TAG, "IllegalArgumentException caught in ThermalParser");
            } catch (XmlPullParserException xppe) {
                Log.e(TAG, "XmlPullParserException caught in ThermalParser");
            }

            try {
                mInputStream = new FileReader(fname);
                mPlatformInfo = null;
                mCurrSensor = null;
                mCurrZone = null;
                mThermalZones = null;
                if (mInputStream == null) return;
                if (mParser != null) {
                    mParser.setInput(mInputStream);
                }
            } catch (FileNotFoundException e) {
                Log.e(TAG, "FileNotFoundException Exception in ThermalParser()");
            } catch (XmlPullParserException e) {
                Log.e(TAG, "XmlPullParserException Exception in ThermalParser()");
            }
        }

        ThermalParser() {
            mParser = mContext.getResources().
                    getXml(ThermalManager.sSensorFileXmlId);
        }

        public ThermalManager.PlatformInfo getPlatformInfo() {
            return mPlatformInfo;
        }

        public boolean parse() {
            if (ThermalManager.sIsOverlays == false && mInputStream == null) return false;
            /* if mParser is null, close any open stream before exiting */
            if (mParser == null) {
                try {
                    if (mInputStream != null) {
                        mInputStream.close();
                    }
                } catch (IOException e) {
                    Log.i(TAG, "IOException caught in parse() function");
                }
                return false;
            }

            boolean ret = true;
            MetaTag tag = MetaTag.ENUM_UNKNOWN;
            try {
                int mEventType = mParser.getEventType();
                while (mEventType != XmlPullParser.END_DOCUMENT && !mDone) {
                    switch (mEventType) {
                        case XmlPullParser.START_DOCUMENT:
                            Log.i(TAG, "StartDocument");
                            break;
                        case XmlPullParser.START_TAG:
                            String tagName = mParser.getName();
                            boolean isMetaTag = false;
                            if (tagName != null && tagName.equalsIgnoreCase(ZONETHRESHOLD)) {
                                tag = MetaTag.ENUM_ZONETHRESHOLD;
                                isMetaTag = true;
                            } else if (tagName != null && tagName.equalsIgnoreCase(POLLDELAY)) {
                                tag = MetaTag.ENUM_POLLDELAY;
                                isMetaTag = true;
                            } else if (tagName != null
                                    && tagName.equalsIgnoreCase(MOVINGAVGWINDOW)) {
                                tag = MetaTag.ENUM_MOVINGAVGWINDOW;
                                isMetaTag = true;
                            }
                            if (isMetaTag) {
                                ret = processMetaTag(tagName, tag);
                            } else {
                                ret = processStartElement(tagName);
                            }
                            if (!ret) {
                                if (mInputStream != null) mInputStream.close();
                                return false;
                            }
                            break;
                        case XmlPullParser.END_TAG:
                            processEndElement(mParser.getName());
                            break;
                    }
                    mEventType = mParser.next();
                }
            } catch (XmlPullParserException xppe) {
                Log.i(TAG, "XmlPullParserException caught in parse():" + xppe.getMessage());
                ret = false;
            } catch (IOException e) {
                Log.i(TAG, "IOException caught in parse():" + e.getMessage());
                ret = false;
            } finally {
                try {
                    // end of parsing, close the stream
                    // close is moved here, since if there is an exception
                    // while parsing doc, input stream needs to be closed
                    if (mInputStream != null) mInputStream.close();
                } catch (IOException e) {
                    Log.i(TAG, "IOException caught in parse() function");
                    ret = false;
                }
                return ret;
            }
        }

        boolean processMetaTag(String tagName, MetaTag tagId) {
            if (mParser == null || tagName == null || mCurrZone == null)  return false;
            ArrayList<Integer> tempList;
            tempList = new ArrayList<Integer>();
            // add the dummy value for TOFF now. update it once meta tag parsed
            tempList.add(0);
            try {
                int eventType = mParser.next();
                while (true) {
                    if (eventType == XmlPullParser.START_TAG) {
                        tempList.add(Integer.parseInt(mParser.nextText()));
                    } else if (eventType == XmlPullParser.END_TAG &&
                            mParser.getName().equalsIgnoreCase(tagName)) {
                        break;
                    }
                    eventType = mParser.next();
                }
            } catch (XmlPullParserException xppe) {
                Log.e(TAG, "XmlPullParserException:" + xppe.getMessage());
                return false;
            } catch (IOException ioe) {
                Log.e(TAG, "IOException:" + ioe.getMessage());
                return false;
            }
            // now that all state values are parse, copy the value corresponding to <normal>
            // state to TOFF and last state to CRITICAL state.
            // now we have reached end of meta tag add this temp list to appropriate list
            switch(tagId) {
                case ENUM_POLLDELAY:
                    // add TOFF
                    tempList.set(0, tempList.get(1));
                    // add TCRITICAL
                    tempList.add(tempList.get(tempList.size() - 1));
                    mCurrZone.setPollDelay(tempList);
                    break;
                case ENUM_ZONETHRESHOLD:
                    // add TCRITICAL
                    tempList.add(tempList.get(tempList.size() - 1));
                    mCurrZone.updateMaxStates(tempList.size());
                    mCurrZone.setZoneTempThreshold(tempList);
                    break;
                case ENUM_MOVINGAVGWINDOW:
                    // add TOFF
                    tempList.set(0, tempList.get(1));
                    // add TCRITICAL
                    tempList.add(tempList.get(tempList.size() - 1));
                    mCurrZone.setMovingAvgWindow(tempList);
                    break;
                case ENUM_UNKNOWN:
                default:
                    break;
            }
            tempList = null;
            return true;
        }

        boolean processStartElement(String name) {
            if (name == null)
                return false;
            String zoneName;
            boolean ret = true;
            try {
                if (name.equalsIgnoreCase(PINFO)) {
                    mPlatformInfo = new ThermalManager.PlatformInfo();
                    // Default Thermal States
                    mPlatformInfo.mMaxThermalStates = 5;
                } else if (name.equalsIgnoreCase(PROFILE)) {
                    mNumProfiles++;
                } else if (name.equalsIgnoreCase(SENSOR)) {
                    if (mCurrSensor == null) {
                        mCurrSensor = new ThermalSensor();
                    }
                } else if (name.equalsIgnoreCase(SENSOR_ATTRIB)) {
                    if (mCurrSensorAttribList == null) {
                        mCurrSensorAttribList = new ArrayList<ThermalSensorAttrib>();
                    }
                    mCurrSensorAttrib = new ThermalSensorAttrib();
                } else if (name.equalsIgnoreCase(ZONE)) {
                    if (mThermalZones == null)
                        mThermalZones = new ArrayList<ThermalZone>();
                } else {
                    // Retrieve Platform Information
                    if (mPlatformInfo != null && name.equalsIgnoreCase("PlatformThermalStates")) {
                        mPlatformInfo.mMaxThermalStates = Integer.parseInt(mParser.nextText());
                        // Retrieve Zone Information
                    } else if (name.equalsIgnoreCase("ZoneName") && mTempZoneId != -1) {
                        mTempZoneName = mParser.nextText();
                    } else if (name.equalsIgnoreCase("Name")) {
                        mCurProfileName = mParser.nextText();
                    } else if (name.equalsIgnoreCase(ZONELOGIC) && mTempZoneId != -1
                            && mTempZoneName != null) {
                        String zoneLogic = mParser.nextText();
                        if (zoneLogic.equalsIgnoreCase("VirtualSkin")) {
                            mCurrZone = new VirtualThermalZone();
                        } else {
                            // default zone raw
                            mCurrZone = new RawThermalZone();
                        }
                        if (mCurrZone != null) {
                            mCurrZone.setZoneName(mTempZoneName);
                            mCurrZone.setZoneId(mTempZoneId);
                            mCurrZone.setZoneLogic(zoneLogic);
                        }
                    } else if (name.equalsIgnoreCase("ZoneID")) {
                        mTempZoneId = Integer.parseInt(mParser.nextText());
                    } else if (name.equalsIgnoreCase("SupportsUEvent") && mCurrZone != null)
                        mCurrZone.setSupportsUEvent(Integer.parseInt(mParser.nextText()));
                    else if (name.equalsIgnoreCase("SupportsEmulTemp") && mCurrZone != null)
                        mCurrZone.setEmulTempFlag(Integer.parseInt(mParser.nextText()));
                    else if (name.equalsIgnoreCase("DebounceInterval") && mCurrZone != null)
                        mCurrZone.setDBInterval(Integer.parseInt(mParser.nextText()));
                    else if (name.equalsIgnoreCase(POLLDELAY) && mCurrZone != null) {
                        mPollDelayList = new ArrayList<Integer>();
                    } else if (name.equalsIgnoreCase(OFFSET) && mCurrZone != null) {
                        mCurrZone.setOffset(Integer.parseInt(mParser.nextText()));
                    }

                    // Retrieve Sensor Information
                    else if (name.equalsIgnoreCase("SensorName")) {
                        if (mCurrSensorAttrib != null) {
                            mCurrSensorAttrib.setSensorName(mParser.nextText());
                        } else if (mCurrSensor != null) {
                            mCurrSensor.setSensorName(mParser.nextText());
                        }
                    } else if (name.equalsIgnoreCase("SensorPath") && mCurrSensor != null)
                        mCurrSensor.setSensorPath(mParser.nextText());
                    else if (name.equalsIgnoreCase("InputTemp") && mCurrSensor != null)
                        mCurrSensor.setInputTempPath(mParser.nextText());
                    else if (name.equalsIgnoreCase("HighTemp") && mCurrSensor != null)
                        mCurrSensor.setHighTempPath(mParser.nextText());
                    else if (name.equalsIgnoreCase("LowTemp") && mCurrSensor != null)
                        mCurrSensor.setLowTempPath(mParser.nextText());
                    else if (name.equalsIgnoreCase("UEventDevPath") && mCurrSensor != null)
                        mCurrSensor.setUEventDevPath(mParser.nextText());
                    else if (name.equalsIgnoreCase("ErrorCorrection") && mCurrSensor != null)
                        mCurrSensor.setErrorCorrectionTemp(Integer.parseInt(mParser.nextText()));
                    else if (name.equalsIgnoreCase(WEIGHT) && mCurrSensorAttrib != null) {
                        if (mWeightList == null) {
                            mWeightList = new ArrayList<Integer>();
                        }
                        if (mWeightList != null) {
                            mWeightList.add(Integer.parseInt(mParser.nextText()));
                        }
                    } else if (name.equalsIgnoreCase(ORDER) && mCurrSensorAttrib != null) {
                        if (mOrderList == null) {
                            mOrderList = new ArrayList<Integer>();
                        }
                        if (mOrderList != null) {
                            mOrderList.add(Integer.parseInt(mParser.nextText()));
                        }
                    }
                }
            } catch (XmlPullParserException e) {
                Log.i(TAG, "XmlPullParserException caught in processStartElement()");
                ret = false;
            } catch (IOException e) {
                Log.i(TAG, "IOException caught in processStartElement()");
                ret = false;
            } finally {
                return ret;
            }
        }

        void processEndElement(String name) {
            if (name.equalsIgnoreCase(SENSOR)) {
                // insert in map, only if no sensor with same name already in map
                if (mCurrSensor == null) return;
                mCurrSensor.setAutoValues();
                if (ThermalManager.getSensor(mCurrSensor.getSensorName()) == null) {
                    ThermalManager.sSensorMap.put(mCurrSensor.getSensorName(), mCurrSensor);
                } else {
                    Log.i(TAG, "sensor:" + mCurrSensor.getSensorName() + " already present");
                }
                mCurrSensor = null;
            } else if (name.equalsIgnoreCase(SENSOR_ATTRIB) && mCurrSensorAttribList != null) {
                if (mCurrSensorAttrib != null) {
                    mCurrSensorAttrib.setWeights(mWeightList);
                    mCurrSensorAttrib.setOrder(mOrderList);
                }
                mWeightList = null;
                mOrderList = null;
                if (mCurrSensorAttrib != null
                        && ThermalManager.getSensor(mCurrSensorAttrib.getSensorName()) != null) {
                    // this is valid sensor, so now update the zone sensorattrib list
                    // and sensor list.This check is needed to avoid a scenario where
                    // a invalid sensor name might be included in sensorattrib list.
                    // This check filters out all invalid sensor attrib.
                    mCurrSensorAttribList.add(mCurrSensorAttrib);
                }
            } else if (name.equalsIgnoreCase(ZONE) && mCurrZone != null
                    && mThermalZones != null) {
                mCurrZone.setSensorList(mCurrSensorAttribList);
                mThermalZones.add(mCurrZone);
                mCurrZone = null;
                mTempZoneId = -1;
                mTempZoneName = null;
                mCurrSensorAttribList = null;
            } else if (name.equalsIgnoreCase(POLLDELAY) && mCurrZone != null) {
                mCurrZone.setPollDelay(mPollDelayList);
                mPollDelayList = null;
            } else if (name.equalsIgnoreCase(MOVINGAVGWINDOW) && mCurrZone != null) {
                mCurrZone.setMovingAvgWindow(mMovingAvgWindowList);
                mMovingAvgWindowList = null;
            } else if (name.equalsIgnoreCase(THERMAL_CONFIG)) {
                // This indicates we have not seen any <Profile> tag.
                // Consider it as if we have only one 'Default' Profile.
                if (mNumProfiles == 0) {
                    ThermalManager.sProfileZoneMap.put(mCurProfileName, mThermalZones);
                }
                mDone = true;
            } else if (name.equalsIgnoreCase(PROFILE)) {
                ThermalManager.sProfileZoneMap.put(mCurProfileName, mThermalZones);
                mThermalZones = null;
            } else if (name.equalsIgnoreCase(ZONETHRESHOLD) && mCurrZone != null) {
                mCurrZone.setZoneTempThreshold(mZoneThresholdList);
                mZoneThresholdList = null;
            }
        }
    }

    /* Class to notifying thermal events */
    public class Notify implements Runnable {
        private final BlockingQueue cQueue;
        Notify (BlockingQueue q) {
            cQueue = q;
        }

        public void run () {
            try {
                while (true) { consume((ThermalEvent) cQueue.take()); }
            } catch (InterruptedException ex) {
                Log.i(TAG, "caught InterruptedException in run()");
            }
        }

        /* Method to consume thermal event */
        public void consume (ThermalEvent event) {
            Intent statusIntent = new Intent();
            statusIntent.setAction(ThermalManager.ACTION_THERMAL_ZONE_STATE_CHANGED);

            statusIntent.putExtra(ThermalManager.EXTRA_NAME, event.mZoneName);
            statusIntent.putExtra(ThermalManager.EXTRA_PROFILE, event.mProfName);
            statusIntent.putExtra(ThermalManager.EXTRA_ZONE, event.mZoneId);
            statusIntent.putExtra(ThermalManager.EXTRA_EVENT, event.mEventType);
            statusIntent.putExtra(ThermalManager.EXTRA_STATE, event.mThermalLevel);
            statusIntent.putExtra(ThermalManager.EXTRA_TEMP, event.mZoneTemp);

            /* Send the Thermal Intent */
            mContext.sendBroadcastAsUser(statusIntent, UserHandle.ALL);
        }
    }

    /* Register for boot complete Intent */
    public ThermalService() {
        super();
    }

    private void configureTurboProperties() {
        String prop = SystemProperties.get("persist.thermal.turbo.dynamic");

        if (prop.equals("0")) {
            ThermalManager.sIsDynamicTurboEnabled = false;
            Log.i(TAG, "Dynamic Turbo disabled through persist.thermal.turbo.dynamic");
        } else if (prop.equals("1")) {
            ThermalManager.sIsDynamicTurboEnabled = true;
            Log.i(TAG, "Dynamic Turbo enabled through persist.thermal.turbo.dynamic");
        } else {
            // Set it to true so that we don't write ThermalManager.DISABLE_DYNAMIC_TURBO
            // into any cooling device based on this.
            ThermalManager.sIsDynamicTurboEnabled = true;
            Log.i(TAG, "property persist.thermal.turbo.dynamic not present");
        }
    }

    @Override
    public void onDestroy() {
        // stop all thread
        ThermalManager.stopCurrentProfile();
        ThermalManager.sCoolingManager.unregisterReceivers();
        // clear all static data
        ThermalManager.clearData();
        Log.w(TAG, "ituxd destroyed");
    }

    @Override
    public void onCreate() {
        mContext = getApplicationContext();
        ThermalManager.setContext(mContext);
    }

    @Override
    public IBinder onBind(Intent intent) {
        return(null);
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startid)
    {
        boolean ret;
        ThermalManager.loadiTUXVersion();
        /* Check for exitence of config files */
        ThermalUtils.initialiseConfigFiles(mContext);
        if (!ThermalManager.sIsConfigFiles && !ThermalManager.sIsOverlays) {
            Log.i(TAG, "Thermal config files do not exist. Exiting ThermalService");
            return START_NOT_STICKY;
        }

        /* Set Dynamic Turbo status based on the property */
        configureTurboProperties();

        /* Intiliaze DTS TjMax temperature */
        ThermalUtils.getTjMax();

        /* Initialize the Thermal Cooling Manager */
        ThermalManager.sCoolingManager = new ThermalCooling();
        if (ThermalManager.sCoolingManager != null) {
            ret = ThermalManager.sCoolingManager.init(mContext);
            if (!ret) {
                Log.i(TAG, "CoolingManager is null. Exiting ThermalService");
                return START_NOT_STICKY;
            }
        }

        /* Parse the thermal configuration file to determine zone/sensor information */
        ThermalParser mThermalParser;
        if (ThermalManager.sIsConfigFiles) {
            mThermalParser = new ThermalParser(ThermalManager.sSensorFilePath);
        } else {
            mThermalParser = new ThermalParser();
        }

        if (mThermalParser != null) {
            ret = mThermalParser.parse();
            if (!ret) {
                ThermalManager.sCoolingManager.unregisterReceivers();
                Log.i(TAG, "thermal_sensor_config.xml parsing Failed. Exiting ThermalService");
                return START_NOT_STICKY;
            }
        }

        /* Retrieve the platform information after parsing */
        ThermalManager.sPlatformInfo = mThermalParser.getPlatformInfo();

        /* Print thermal_sensor_config.xml information */
        Iterator it = ThermalManager.sProfileZoneMap.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry entry = (Map.Entry) it.next();
            String key = (String) entry.getKey();
            ArrayList<ThermalZone> tzList = (ArrayList<ThermalZone>) entry.getValue();
            Log.i(TAG, "Zones under Profile: " + key);
            for (ThermalZone tz : tzList) tz.printAttrs();
        }

        /* read persistent system properties for shutdown notification */
        ThermalManager.readShutdownNotiferProperties();
        /* initialize the thermal notifier thread */
        Notify notifier = new Notify(ThermalManager.sEventQueue);
        new Thread(notifier, "ThermalNotifier").start();

        ThermalManager.buildProfileNameList();
        ThermalManager.initializeStickyIntent();

        /* Building bucket size for all profiles */
        ThermalManager.setBucketSizeForProfiles();

        /* Start monitoring the zones in Default Thermal Profile */
        ThermalManager.startDefaultProfile();

        return START_STICKY;
    }
}