Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 176f07a7 authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge changes from topic 'thermal-notify-mr1' into oc-mr1-dev 

* changes:
  thermalservice: add HIDL ThermalCallback implementation
  thermalservice: add ThermalService interfaces and thermalserviced
parents 3a02aee2 c7d606d4

services/thermalservice/Android.bp

0 → 100644
+61 −0
Original line number Diff line number Diff line 
subdirs = [

    "libthermalcallback"

]



cc_library {

    name: "libthermalservice",



    srcs: [

        "aidl/android/os/IThermalEventListener.aidl",

        "aidl/android/os/IThermalService.aidl",

        "aidl/android/os/Temperature.cpp",

    ],

    aidl: {

      include_dirs: ["frameworks/native/services/thermalservice/aidl"],

      export_aidl_headers: true,

    },

    export_include_dirs: ["aidl"],



    shared_libs: [

        "libbinder",

        "libutils",

    ],



    cflags: [

        "-Wall",

        "-Werror",

        "-Wunused",

        "-Wunreachable-code",

    ],

}



cc_binary {

    name: "thermalserviced",



    srcs: [

        "ThermalService.cpp",

        "thermalserviced.cpp",

    ],



    include_dirs: ["frameworks/native"],



    shared_libs: [

        "libthermalservice",

        "libbinder",

        "libutils",

        "libthermalcallback",

        "android.hardware.thermal@1.1",

        "libhidlbase",

        "libhidltransport",

        "liblog",

    ],



    cflags: [

        "-Wall",

        "-Werror",

        "-Wunused",

        "-Wunreachable-code",

    ],



    init_rc: ["thermalservice.rc"],

}

services/thermalservice/ThermalService.cpp

0 → 100644
+126 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2017 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.

 */



#include "ThermalService.h"

#include <android/os/IThermalService.h>

#include <android/os/IThermalEventListener.h>

#include <android/os/Temperature.h>

#include <binder/IPCThreadState.h>

#include <binder/IServiceManager.h>

#include <utils/Errors.h>

#include <utils/Mutex.h>

#include <utils/String16.h>



namespace android {

namespace os {



/**

 * Notify registered listeners of a thermal throttling start/stop event.

 * @param temperature the temperature at which the event was generated

 */

binder::Status ThermalService::notifyThrottling(

    const bool isThrottling, const Temperature& temperature) {

    Mutex::Autolock _l(mListenersLock);



    mThrottled = isThrottling;

    mThrottleTemperature = temperature;



    for (size_t i = 0; i < mListeners.size(); i++) {

      mListeners[i]->notifyThrottling(isThrottling, temperature);

    }

    return binder::Status::ok();

}



/**

 * Query whether the system is currently thermal throttling.

 * @return true if currently thermal throttling, else false

 */

binder::Status ThermalService::isThrottling(bool* _aidl_return) {

    Mutex::Autolock _l(mListenersLock);

    *_aidl_return = mThrottled;

    return binder::Status::ok();

}



/**

 * Register a new thermal event listener.

 * @param listener the client's IThermalEventListener instance to which

 *                 notifications are to be sent

 */

binder::Status ThermalService::registerThermalEventListener(

    const sp<IThermalEventListener>& listener) {

    {

        if (listener == NULL)

            return binder::Status::ok();

        Mutex::Autolock _l(mListenersLock);

        // check whether this is a duplicate

        for (size_t i = 0; i < mListeners.size(); i++) {

            if (IInterface::asBinder(mListeners[i]) ==

                IInterface::asBinder(listener)) {

                return binder::Status::ok();

            }

        }



        mListeners.add(listener);

        IInterface::asBinder(listener)->linkToDeath(this);

    }



    return binder::Status::ok();

}



/**

 * Unregister a previously-registered thermal event listener.

 * @param listener the client's IThermalEventListener instance to which

 *                 notifications are to no longer be sent

 */

binder::Status ThermalService::unregisterThermalEventListener(

    const sp<IThermalEventListener>& listener) {

    if (listener == NULL)

        return binder::Status::ok();

    Mutex::Autolock _l(mListenersLock);

    for (size_t i = 0; i < mListeners.size(); i++) {

        if (IInterface::asBinder(mListeners[i]) ==

            IInterface::asBinder(listener)) {

            IInterface::asBinder(mListeners[i])->unlinkToDeath(this);

            mListeners.removeAt(i);

            break;

        }

    }



    return binder::Status::ok();

}



void ThermalService::binderDied(const wp<IBinder>& who) {

    Mutex::Autolock _l(mListenersLock);



    for (size_t i = 0; i < mListeners.size(); i++) {

        if (IInterface::asBinder(mListeners[i]) == who) {

            mListeners.removeAt(i);

            break;

        }

    }

}



/**

 * Publish the supplied ThermalService to servicemanager.

 */

void ThermalService::publish(

    const sp<ThermalService>& service) {

    defaultServiceManager()->addService(String16("thermalservice"),

                                        service);

}



}  // namespace os

}  // namespace android

services/thermalservice/ThermalService.h

0 → 100644
+55 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2017 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.

 */



#ifndef ANDROID_THERMALSERVICE_THERMALSERVICE_H

#define ANDROID_THERMALSERVICE_THERMALSERVICE_H



#include <android/os/BnThermalService.h>

#include <android/os/IThermalEventListener.h>

#include <android/os/Temperature.h>

#include <utils/Mutex.h>

#include <utils/String16.h>

#include <utils/Vector.h>



namespace android {

namespace os {



class ThermalService : public BnThermalService,

                       public IBinder::DeathRecipient {

public:

  ThermalService() : mThrottled(false) {};

    void publish(const sp<ThermalService>& service);

    binder::Status notifyThrottling(

        const bool isThrottling, const Temperature& temperature);



private:

    Mutex mListenersLock;

    Vector<sp<IThermalEventListener> > mListeners;

    bool mThrottled;

    Temperature mThrottleTemperature;



    binder::Status registerThermalEventListener(

        const sp<IThermalEventListener>& listener);

    binder::Status unregisterThermalEventListener(

        const sp<IThermalEventListener>& listener);

    binder::Status isThrottling(bool* _aidl_return);

    void binderDied(const wp<IBinder>& who);

};



};  // namespace os

};  // namespace android



#endif // ANDROID_THERMALSERVICE_THERMALSERVICE_H

services/thermalservice/aidl/android/os/IThermalEventListener.aidl

0 → 100644
+32 −0
Original line number Diff line number Diff line 
/**

 * Copyright (c) 2017, The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



package android.os;



import android.os.Temperature;



/**

  * Listener for thermal events.

  * {@hide}

  */

oneway interface IThermalEventListener {

    /**

     * Called when a thermal throttling start/stop event is received.

     * @param temperature the temperature at which the event was generated.

     */

    void notifyThrottling(

        in boolean isThrottling, in Temperature temperature);

}

services/thermalservice/aidl/android/os/IThermalService.aidl

0 → 100644
+48 −0
Original line number Diff line number Diff line 
/**

 * Copyright (c) 2017, The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



package android.os;



import android.os.IThermalEventListener;

import android.os.Temperature;



/** {@hide} */

interface IThermalService {

    /**

      * Register a listener for thermal events.

      * @param listener the IThermalEventListener to be notified.

      * {@hide}

      */

    void registerThermalEventListener(in IThermalEventListener listener);

    /**

      * Unregister a previously-registered listener for thermal events.

      * @param listener the IThermalEventListener to no longer be notified.

      * {@hide}

      */

    void unregisterThermalEventListener(in IThermalEventListener listener);

    /**

      * Send a thermal throttling start/stop notification to all listeners.

      * @param temperature the temperature at which the event was generated.

      * {@hide}

      */

    oneway void notifyThrottling(

        in boolean isThrottling, in Temperature temperature);

    /**

      * Return whether system performance is currently thermal throttling.

      * {@hide}

      */

    boolean isThrottling();

}