libs/common_time/common_clock_service.cpp

   1 /*
   2  * Copyright (C) 2011 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <common_time/local_clock.h>
  18 #include <utils/String8.h>
  19
  20 #include "common_clock_service.h"
  21 #include "common_clock.h"
  22 #include "common_time_server.h"
  23
  24 namespace android {
  25
  26 sp<CommonClockService> CommonClockService::instantiate(
  27         CommonTimeServer& timeServer) {
  28     sp<CommonClockService> tcc = new CommonClockService(timeServer);
  29     if (tcc == NULL)
  30         return NULL;
  31
  32     defaultServiceManager()->addService(ICommonClock::kServiceName, tcc);
  33     return tcc;
  34 }
  35
  36 status_t CommonClockService::dump(int fd, const Vector<String16>& args) {
  37     Mutex::Autolock lock(mRegistrationLock);
  38     return mTimeServer.dumpClockInterface(fd, args, mListeners.size());
  39 }
  40
  41 status_t CommonClockService::isCommonTimeValid(bool* valid,
  42                                                uint32_t* timelineID) {
  43     return mTimeServer.isCommonTimeValid(valid, timelineID);
  44 }
  45
  46 status_t CommonClockService::commonTimeToLocalTime(int64_t  commonTime,
  47                                                    int64_t* localTime) {
  48     return mTimeServer.getCommonClock().commonToLocal(commonTime, localTime);
  49 }
  50
  51 status_t CommonClockService::localTimeToCommonTime(int64_t  localTime,
  52                                                    int64_t* commonTime) {
  53     return mTimeServer.getCommonClock().localToCommon(localTime, commonTime);
  54 }
  55
  56 status_t CommonClockService::getCommonTime(int64_t* commonTime) {
  57     return localTimeToCommonTime(mTimeServer.getLocalClock().getLocalTime(), commonTime);
  58 }
  59
  60 status_t CommonClockService::getCommonFreq(uint64_t* freq) {
  61     *freq = mTimeServer.getCommonClock().getCommonFreq();
  62     return OK;
  63 }
  64
  65 status_t CommonClockService::getLocalTime(int64_t* localTime) {
  66     *localTime = mTimeServer.getLocalClock().getLocalTime();
  67     return OK;
  68 }
  69
  70 status_t CommonClockService::getLocalFreq(uint64_t* freq) {
  71     *freq = mTimeServer.getLocalClock().getLocalFreq();
  72     return OK;
  73 }
  74
  75 status_t CommonClockService::getEstimatedError(int32_t* estimate) {
  76     *estimate = mTimeServer.getEstimatedError();
  77     return OK;
  78 }
  79
  80 status_t CommonClockService::getTimelineID(uint64_t* id) {
  81     *id = mTimeServer.getTimelineID();
  82     return OK;
  83 }
  84
  85 status_t CommonClockService::getState(State* state) {
  86     *state = mTimeServer.getState();
  87     return OK;
  88 }
  89
  90 status_t CommonClockService::getMasterAddr(struct sockaddr_storage* addr) {
  91     return mTimeServer.getMasterAddr(addr);
  92 }
  93
  94 status_t CommonClockService::registerListener(
  95         const sp<ICommonClockListener>& listener) {
  96     Mutex::Autolock lock(mRegistrationLock);
  97
  98     {   // scoping for autolock pattern
  99         Mutex::Autolock lock(mCallbackLock);
 100         // check whether this is a duplicate
 101         for (size_t i = 0; i < mListeners.size(); i++) {
 102             if (IInterface::asBinder(mListeners[i]) == IInterface::asBinder(listener))
 103                 return ALREADY_EXISTS;
 104         }
 105     }
 106
 107     mListeners.add(listener);
 108     mTimeServer.reevaluateAutoDisableState(0 != mListeners.size());
 109     return IInterface::asBinder(listener)->linkToDeath(this);
 110 }
 111
 112 status_t CommonClockService::unregisterListener(
 113         const sp<ICommonClockListener>& listener) {
 114     Mutex::Autolock lock(mRegistrationLock);
 115     status_t ret_val = NAME_NOT_FOUND;
 116
 117     {   // scoping for autolock pattern
 118         Mutex::Autolock lock(mCallbackLock);
 119         for (size_t i = 0; i < mListeners.size(); i++) {
 120             if (IInterface::asBinder(mListeners[i]) == IInterface::asBinder(listener)) {
 121                 IInterface::asBinder(mListeners[i])->unlinkToDeath(this);
 122                 mListeners.removeAt(i);
 123                 ret_val = OK;
 124                 break;
 125             }
 126         }
 127     }
 128
 129     mTimeServer.reevaluateAutoDisableState(0 != mListeners.size());
 130     return ret_val;
 131 }
 132
 133 void CommonClockService::binderDied(const wp<IBinder>& who) {
 134     Mutex::Autolock lock(mRegistrationLock);
 135
 136     {   // scoping for autolock pattern
 137         Mutex::Autolock lock(mCallbackLock);
 138         for (size_t i = 0; i < mListeners.size(); i++) {
 139             if (IInterface::asBinder(mListeners[i]) == who) {
 140                 mListeners.removeAt(i);
 141                 break;
 142             }
 143         }
 144     }
 145
 146     mTimeServer.reevaluateAutoDisableState(0 != mListeners.size());
 147 }
 148
 149 void CommonClockService::notifyOnTimelineChanged(uint64_t timelineID) {
 150     Mutex::Autolock lock(mCallbackLock);
 151
 152     for (size_t i = 0; i < mListeners.size(); i++) {
 153         mListeners[i]->onTimelineChanged(timelineID);
 154     }
 155 }
 156
 157 }; // namespace android