Merge "Remove common_time code" am: d2285710

/*

 * Copyright (C) 2011 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_ICOMMONCLOCK_H

#define ANDROID_ICOMMONCLOCK_H

#include <stdint.h>

#include <linux/socket.h>

#include <binder/IInterface.h>

#include <binder/IServiceManager.h>

namespace android {

class ICommonClockListener : public IInterface {

  public:

    DECLARE_META_INTERFACE(CommonClockListener);

    virtual void onTimelineChanged(uint64_t timelineID) = 0;

};

class BnCommonClockListener : public BnInterface<ICommonClockListener> {

  public:

    virtual status_t onTransact(uint32_t code, const Parcel& data,

                                Parcel* reply, uint32_t flags = 0);

};

class ICommonClock : public IInterface {

  public:

    DECLARE_META_INTERFACE(CommonClock);

    // Name of the ICommonClock service registered with the service manager.

    static const String16 kServiceName;

    // a reserved invalid timeline ID

    static const uint64_t kInvalidTimelineID;

    // a reserved invalid error estimate

    static const int32_t kErrorEstimateUnknown;

    enum State {

        // the device just came up and is trying to discover the master

        STATE_INITIAL,

        // the device is a client of a master

        STATE_CLIENT,

        // the device is acting as master

        STATE_MASTER,

        // the device has lost contact with its master and needs to participate

        // in the election of a new master

        STATE_RONIN,

        // the device is waiting for announcement of the newly elected master

        STATE_WAIT_FOR_ELECTION,

    };

    virtual status_t isCommonTimeValid(bool* valid, uint32_t* timelineID) = 0;

    virtual status_t commonTimeToLocalTime(int64_t commonTime,

                                           int64_t* localTime) = 0;

    virtual status_t localTimeToCommonTime(int64_t localTime,

                                           int64_t* commonTime) = 0;

    virtual status_t getCommonTime(int64_t* commonTime) = 0;

    virtual status_t getCommonFreq(uint64_t* freq) = 0;

    virtual status_t getLocalTime(int64_t* localTime) = 0;

    virtual status_t getLocalFreq(uint64_t* freq) = 0;

    virtual status_t getEstimatedError(int32_t* estimate) = 0;

    virtual status_t getTimelineID(uint64_t* id) = 0;

    virtual status_t getState(State* state) = 0;

    virtual status_t getMasterAddr(struct sockaddr_storage* addr) = 0;

    virtual status_t registerListener(

            const sp<ICommonClockListener>& listener) = 0;

    virtual status_t unregisterListener(

            const sp<ICommonClockListener>& listener) = 0;

    // Simple helper to make it easier to connect to the CommonClock service.

    static inline sp<ICommonClock> getInstance() {

        sp<IBinder> binder = defaultServiceManager()->checkService(

                ICommonClock::kServiceName);

        sp<ICommonClock> clk = interface_cast<ICommonClock>(binder);

        return clk;

    }

};

class BnCommonClock : public BnInterface<ICommonClock> {

  public:

    virtual status_t onTransact(uint32_t code, const Parcel& data,

                                Parcel* reply, uint32_t flags = 0);

};

};  // namespace android

#endif  // ANDROID_ICOMMONCLOCK_H

/*

 * Copyright (C) 2012 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_ICOMMONTIMECONFIG_H

#define ANDROID_ICOMMONTIMECONFIG_H

#include <stdint.h>

#include <linux/socket.h>

#include <binder/IInterface.h>

#include <binder/IServiceManager.h>

namespace android {

class String16;

class ICommonTimeConfig : public IInterface {

  public:

    DECLARE_META_INTERFACE(CommonTimeConfig);

    // Name of the ICommonTimeConfig service registered with the service

    // manager.

    static const String16 kServiceName;

    virtual status_t getMasterElectionPriority(uint8_t *priority) = 0;

    virtual status_t setMasterElectionPriority(uint8_t priority) = 0;

    virtual status_t getMasterElectionEndpoint(struct sockaddr_storage *addr) = 0;

    virtual status_t setMasterElectionEndpoint(const struct sockaddr_storage *addr) = 0;

    virtual status_t getMasterElectionGroupId(uint64_t *id) = 0;

    virtual status_t setMasterElectionGroupId(uint64_t id) = 0;

    virtual status_t getInterfaceBinding(String16& ifaceName) = 0;

    virtual status_t setInterfaceBinding(const String16& ifaceName) = 0;

    virtual status_t getMasterAnnounceInterval(int *interval) = 0;

    virtual status_t setMasterAnnounceInterval(int interval) = 0;

    virtual status_t getClientSyncInterval(int *interval) = 0;

    virtual status_t setClientSyncInterval(int interval) = 0;

    virtual status_t getPanicThreshold(int *threshold) = 0;

    virtual status_t setPanicThreshold(int threshold) = 0;

    virtual status_t getAutoDisable(bool *autoDisable) = 0;

    virtual status_t setAutoDisable(bool autoDisable) = 0;

    virtual status_t forceNetworklessMasterMode() = 0;

    // Simple helper to make it easier to connect to the CommonTimeConfig service.

    static inline sp<ICommonTimeConfig> getInstance() {

        sp<IBinder> binder = defaultServiceManager()->checkService(

                ICommonTimeConfig::kServiceName);

        sp<ICommonTimeConfig> clk = interface_cast<ICommonTimeConfig>(binder);

        return clk;

    }

};

class BnCommonTimeConfig : public BnInterface<ICommonTimeConfig> {

  public:

    virtual status_t onTransact(uint32_t code, const Parcel& data,

                                Parcel* reply, uint32_t flags = 0);

};

};  // namespace android

#endif  // ANDROID_ICOMMONTIMECONFIG_H

/*

 * Copyright (C) 2011 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 __CC_HELPER_H__

#define __CC_HELPER_H__

#include <stdint.h>

#include <common_time/ICommonClock.h>

#include <utils/threads.h>

namespace android {

// CCHelper is a simple wrapper class to help with centralizing access to the

// Common Clock service and implementing lifetime managment, as well as to

// implement a simple policy of making a basic attempt to reconnect to the

// common clock service when things go wrong.

//

// On platforms which run the native common_time service in auto-disable mode,

// the service will go into networkless mode whenever it has no active clients.

// It tracks active clients using registered CommonClockListeners (the callback

// interface for onTimelineChanged) since this provides a convienent death

// handler notification for when the service's clients die unexpectedly.  This

// means that users of the common time service should really always have a

// CommonClockListener, unless they know that the time service is not running in

// auto disabled mode, or that there is at least one other registered listener

// active in the system.  The CCHelper makes this a little easier by sharing a

// ref counted ICommonClock interface across all clients and automatically

// registering and unregistering a listener whenever there are CCHelper

// instances active in the process.

class CCHelper {

  public:

    CCHelper();

    ~CCHelper();

    status_t isCommonTimeValid(bool* valid, uint32_t* timelineID);

    status_t commonTimeToLocalTime(int64_t commonTime, int64_t* localTime);

    status_t localTimeToCommonTime(int64_t localTime, int64_t* commonTime);

    status_t getCommonTime(int64_t* commonTime);

    status_t getCommonFreq(uint64_t* freq);

    status_t getLocalTime(int64_t* localTime);

    status_t getLocalFreq(uint64_t* freq);

  private:

    class CommonClockListener : public BnCommonClockListener {

      public:

        void onTimelineChanged(uint64_t timelineID);

    };

    static bool verifyClock_l();

    static Mutex lock_;

    static sp<ICommonClock> common_clock_;

    static sp<ICommonClockListener> common_clock_listener_;

    static uint32_t ref_count_;

};

}  // namespace android

#endif  // __CC_HELPER_H__

/*

 * Copyright (C) 2011 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 __LOCAL_CLOCK_H__

#define __LOCAL_CLOCK_H__

#include <stdint.h>

#include <hardware/local_time_hal.h>

#include <utils/Errors.h>

#include <utils/threads.h>

namespace android {

class LocalClock {

  public:

    LocalClock();

    bool initCheck();

    int64_t  getLocalTime();

    uint64_t getLocalFreq();

    status_t setLocalSlew(int16_t rate);

    int32_t  getDebugLog(struct local_time_debug_event* records,

                         int max_records);

  private:

    static Mutex dev_lock_;

    static local_time_hw_device_t* dev_;

};

}  // namespace android

#endif  // __LOCAL_CLOCK_H__

LOCAL_PATH:= $(call my-dir)

#

# libcommon_time_client

# (binder marshalers for ICommonClock as well as common clock and local clock

# helper code)

#

include $(CLEAR_VARS)

LOCAL_MODULE := libcommon_time_client

LOCAL_MODULE_TAGS := optional

LOCAL_SRC_FILES := cc_helper.cpp \

                   local_clock.cpp \

                   ICommonClock.cpp \

                   ICommonTimeConfig.cpp \

                   utils.cpp

LOCAL_SHARED_LIBRARIES := libbinder \

                          libhardware \

                          libutils \

                          liblog

LOCAL_CFLAGS := -Wall -Werror

include $(BUILD_SHARED_LIBRARY)