Merge "Tuner HAL default implementation for ATV for Tuner and Frontend Interface."

cc_defaults {

    name: "tuner_service_defaults",

    defaults: ["hidl_defaults"],

    vendor: true,

    relative_install_path: "hw",

    srcs: [

        "Frontend.cpp",

        "Tuner.cpp",

        "service.cpp",

    ],

    compile_multilib: "first",

    shared_libs: [

        "android.hardware.tv.tuner@1.0",

        "android.hidl.memory@1.0",

        "libhidlbase",

        "libhidlmemory",

        "libhidltransport",

        "liblog",

        "libstagefright_foundation",

        "libutils",

    ],

    header_libs: [

        "media_plugin_headers",

    ],

}

cc_binary {

    name: "android.hardware.tv.tuner@1.0-service",

    vintf_fragments: ["android.hardware.tv.tuner@1.0-service.xml"],

    defaults: ["tuner_service_defaults"],

    init_rc: ["android.hardware.tv.tuner@1.0-service.rc"],

}

cc_binary {

    name: "android.hardware.tv.tuner@1.0-service-lazy",

    vintf_fragments: ["android.hardware.tv.tuner@1.0-service-lazy.xml"],

    overrides: ["android.hardware.tv.tuner@1.0-service"],

    defaults: ["tuner_service_defaults"],

    init_rc: ["android.hardware.tv.tuner@1.0-service-lazy.rc"],

    cflags: ["-DLAZY_SERVICE"],

}

/*

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

 */

#define LOG_TAG "android.hardware.tv.tuner@1.0-Frontend"

#include "Frontend.h"

#include <android/hardware/tv/tuner/1.0/IFrontendCallback.h>

#include <utils/Log.h>

namespace android {

namespace hardware {

namespace tv {

namespace tuner {

namespace V1_0 {

namespace implementation {

Frontend::Frontend() {

    // Init callback to nullptr

    mCallback = nullptr;

}

Frontend::Frontend(FrontendType type, FrontendId id) {

    mType = type;

    mId = id;

    // Init callback to nullptr

    mCallback = nullptr;

}

Frontend::~Frontend() {}

Return<Result> Frontend::close() {

    ALOGV("%s", __FUNCTION__);

    // Reset callback

    mCallback = nullptr;

    return Result::SUCCESS;

}

Return<Result> Frontend::setCallback(const sp<IFrontendCallback>& callback) {

    ALOGV("%s", __FUNCTION__);

    if (callback == nullptr) {

        ALOGW("[   WARN   ] Set Frontend callback with nullptr");

        return Result::INVALID_ARGUMENT;

    }

    mCallback = callback;

    return Result::SUCCESS;

}

Return<Result> Frontend::tune(const FrontendSettings& /* settings */) {

    ALOGV("%s", __FUNCTION__);

    if (mCallback == nullptr) {

        ALOGW("[   WARN   ] Frontend callback is not set when tune");

        return Result::INVALID_STATE;

    }

    mCallback->onEvent(FrontendEventType::NO_SIGNAL);

    return Result::SUCCESS;

}

Return<Result> Frontend::stopTune() {

    ALOGV("%s", __FUNCTION__);

    return Result::SUCCESS;

}

FrontendType Frontend::getFrontendType() {

    return mType;

}

FrontendId Frontend::getFrontendId() {

    return mId;

}

}  // namespace implementation

}  // namespace V1_0

}  // namespace tuner

}  // namespace tv

}  // namespace hardware

}  // namespace android

/*

 * Copyright (C) 2019 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_HARDWARE_TV_TUNER_V1_0_FRONTEND_H_

#define ANDROID_HARDWARE_TV_TUNER_V1_0_FRONTEND_H_

#include <android/hardware/tv/tuner/1.0/IFrontend.h>

#include <android/hardware/tv/tuner/1.0/ITuner.h>

using namespace std;

namespace android {

namespace hardware {

namespace tv {

namespace tuner {

namespace V1_0 {

namespace implementation {

using ::android::hardware::tv::tuner::V1_0::FrontendId;

using ::android::hardware::tv::tuner::V1_0::FrontendType;

using ::android::hardware::tv::tuner::V1_0::IFrontend;

using ::android::hardware::tv::tuner::V1_0::IFrontendCallback;

using ::android::hardware::tv::tuner::V1_0::Result;

class Frontend : public IFrontend {

  public:

    Frontend();

    Frontend(FrontendType type, FrontendId id);

    virtual Return<Result> close() override;

    virtual Return<Result> setCallback(const sp<IFrontendCallback>& callback) override;

    virtual Return<Result> tune(const FrontendSettings& settings) override;

    virtual Return<Result> stopTune() override;

    FrontendType getFrontendType();

    FrontendId getFrontendId();

  private:

    virtual ~Frontend();

    sp<IFrontendCallback> mCallback;

    FrontendType mType = FrontendType::UNDEFINED;

    FrontendId mId = 0;

};

}  // namespace implementation

}  // namespace V1_0

}  // namespace tuner

}  // namespace tv

}  // namespace hardware

}  // namespace android

#endif  // ANDROID_HARDWARE_TV_TUNER_V1_0_FRONTEND_H_

/*

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

 */

#define LOG_TAG "android.hardware.tv.tuner@1.0-Tuner"

#include "Tuner.h"

#include <android/hardware/tv/tuner/1.0/IFrontendCallback.h>

#include <utils/Log.h>

#include "Frontend.h"

namespace android {

namespace hardware {

namespace tv {

namespace tuner {

namespace V1_0 {

namespace implementation {

Tuner::Tuner() {

    // Static Frontends array to maintain local frontends information

    // Array index matches their FrontendId in the default impl

    mFrontendSize = 8;

    mFrontends.resize(mFrontendSize);

    mFrontends[0] = new Frontend();

    mFrontends[1] = new Frontend(FrontendType::ATSC, 1);

    mFrontends[2] = new Frontend(FrontendType::DVBC, 2);

    mFrontends[3] = new Frontend(FrontendType::DVBS, 3);

    mFrontends[4] = new Frontend(FrontendType::DVBT, 4);

    mFrontends[5] = new Frontend(FrontendType::ISDBT, 5);

    mFrontends[6] = new Frontend(FrontendType::ANALOG, 6);

    mFrontends[7] = new Frontend(FrontendType::ATSC, 7);

}

Tuner::~Tuner() {}

Return<void> Tuner::getFrontendIds(getFrontendIds_cb _hidl_cb) {

    ALOGV("%s", __FUNCTION__);

    vector<FrontendId> frontendIds;

    frontendIds.resize(mFrontendSize);

    for (int i = 0; i < mFrontendSize; i++) {

        frontendIds[i] = mFrontends[i]->getFrontendId();

    }

    _hidl_cb(Result::SUCCESS, frontendIds);

    return Void();

}

Return<void> Tuner::openFrontendById(uint32_t frontendId, openFrontendById_cb _hidl_cb) {

    ALOGV("%s", __FUNCTION__);

    if (frontendId >= mFrontendSize || frontendId < 0) {

        ALOGW("[   WARN   ] Frontend with id %d isn't available", frontendId);

        _hidl_cb(Result::UNAVAILABLE, nullptr);

        return Void();

    }

    _hidl_cb(Result::SUCCESS, mFrontends[frontendId]);

    return Void();

}

}  // namespace implementation

}  // namespace V1_0

}  // namespace tuner

}  // namespace tv

}  // namespace hardware

}  // namespace android

/*

 * Copyright (C) 2019 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_HARDWARE_TV_TUNER_V1_0_TUNER_H_

#define ANDROID_HARDWARE_TV_TUNER_V1_0_TUNER_H_

#include <android/hardware/tv/tuner/1.0/ITuner.h>

#include "Frontend.h"

using namespace std;

namespace android {

namespace hardware {

namespace tv {

namespace tuner {

namespace V1_0 {

namespace implementation {

class Tuner : public ITuner {

  public:

    Tuner();

    virtual Return<void> getFrontendIds(getFrontendIds_cb _hidl_cb) override;

    virtual Return<void> openFrontendById(uint32_t frontendId,

                                          openFrontendById_cb _hidl_cb) override;

  private:

    virtual ~Tuner();

    // Static mFrontends array to maintain local frontends information

    vector<sp<Frontend>> mFrontends;

    // To maintain how many Frontends we have

    int mFrontendSize;

};

}  // namespace implementation

}  // namespace V1_0

}  // namespace tuner

}  // namespace tv

}  // namespace hardware

}  // namespace android

#endif  // ANDROID_HARDWARE_TV_TUNER_V1_0_TUNER_H_