Merge "Block access to sensors when Sensor Privacy Mode enabled"

// Copyright 2018 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.

cc_library_shared {

    name: "libsensorprivacy",

    aidl: {

        export_aidl_headers: true,

        local_include_dirs: ["aidl"],

    },

    cflags: [

        "-Wall",

        "-Wextra",

        "-Werror",

        "-Wzero-as-null-pointer-constant",

    ],

    srcs: [

        "aidl/android/hardware/ISensorPrivacyListener.aidl",

        "aidl/android/hardware/ISensorPrivacyManager.aidl",

        "SensorPrivacyManager.cpp",

    ],

    shared_libs: [

        "libbinder",

        "libcutils",

        "libutils",

        "liblog",

        "libhardware",

    ],

    export_include_dirs: ["include"],

    export_shared_lib_headers: ["libbinder"],

}

/*

 * Copyright (C) 2018 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 <mutex>

#include <unistd.h>

#include <binder/Binder.h>

#include <binder/IServiceManager.h>

#include <sensorprivacy/SensorPrivacyManager.h>

#include <utils/SystemClock.h>

namespace android {

SensorPrivacyManager::SensorPrivacyManager()

{

}

sp<hardware::ISensorPrivacyManager> SensorPrivacyManager::getService()

{

    std::lock_guard<Mutex> scoped_lock(mLock);

    int64_t startTime = 0;

    sp<hardware::ISensorPrivacyManager> service = mService;

    while (service == nullptr || !IInterface::asBinder(service)->isBinderAlive()) {

        sp<IBinder> binder = defaultServiceManager()->checkService(String16("sensor_privacy"));

        if (binder == nullptr) {

            // Wait for the sensor privacy service to come back...

            if (startTime == 0) {

                startTime = uptimeMillis();

                ALOGI("Waiting for sensor privacy service");

            } else if ((uptimeMillis() - startTime) > 1000000) {

                ALOGW("Waiting too long for sensor privacy service, giving up");

                service = nullptr;

                break;

            }

            usleep(25000);

        } else {

            service = interface_cast<hardware::ISensorPrivacyManager>(binder);

            mService = service;

        }

    }

    return service;

}

void SensorPrivacyManager::addSensorPrivacyListener(

        const sp<hardware::ISensorPrivacyListener>& listener)

{

    sp<hardware::ISensorPrivacyManager> service = getService();

    if (service != nullptr) {

        service->addSensorPrivacyListener(listener);

    }

}

void SensorPrivacyManager::removeSensorPrivacyListener(

        const sp<hardware::ISensorPrivacyListener>& listener)

{

    sp<hardware::ISensorPrivacyManager> service = getService();

    if (service != nullptr) {

        service->removeSensorPrivacyListener(listener);

    }

}

bool SensorPrivacyManager::isSensorPrivacyEnabled()

{

    sp<hardware::ISensorPrivacyManager> service = getService();

    if (service != nullptr) {

        bool result;

        service->isSensorPrivacyEnabled(&result);

        return result;

    }

    // if the SensorPrivacyManager is not available then assume sensor privacy is disabled

    return false;

}

}; // namespace android

/**

 * Copyright (c) 2018, 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.hardware;

/**

 * @hide

 */

oneway interface ISensorPrivacyListener {

    void onSensorPrivacyChanged(boolean enabled);

}

/**

 * Copyright (c) 2018, 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.hardware;

import android.hardware.ISensorPrivacyListener;

/** @hide */

interface ISensorPrivacyManager {

    void addSensorPrivacyListener(in ISensorPrivacyListener listener);

    void removeSensorPrivacyListener(in ISensorPrivacyListener listener);

    boolean isSensorPrivacyEnabled();

    void setSensorPrivacy(boolean enable);

}

/*

 * Copyright (C) 2018 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_SENSOR_PRIVACY_MANAGER_H

#define ANDROID_SENSOR_PRIVACY_MANAGER_H

#include "android/hardware/ISensorPrivacyListener.h"

#include "android/hardware/ISensorPrivacyManager.h"

#include <utils/threads.h>

// ---------------------------------------------------------------------------

namespace android {

class SensorPrivacyManager

{

public:

    SensorPrivacyManager();

    void addSensorPrivacyListener(const sp<hardware::ISensorPrivacyListener>& listener);

    void removeSensorPrivacyListener(const sp<hardware::ISensorPrivacyListener>& listener);

    bool isSensorPrivacyEnabled();

private:

    Mutex mLock;

    sp<hardware::ISensorPrivacyManager> mService;

    sp<hardware::ISensorPrivacyManager> getService();

};

}; // namespace android

// ---------------------------------------------------------------------------

#endif // ANDROID_SENSOR_PRIVACY_MANAGER_H