1/*
2 * Copyright (C) 2016 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 */
16package android.net;
17
18import android.annotation.SystemApi;
19import android.app.PendingIntent;
20import android.os.Bundle;
21import android.os.Parcelable;
22import android.os.RemoteException;
23import android.os.ServiceManager;
24import android.util.Log;
25
26/** {@hide} */
27@SystemApi
28public class ConnectivityMetricsLogger {
29    private static String TAG = "ConnectivityMetricsLogger";
30    private static final boolean DBG = true;
31
32    public static final String CONNECTIVITY_METRICS_LOGGER_SERVICE = "connectivity_metrics_logger";
33
34    // Component Tags
35    public static final int COMPONENT_TAG_CONNECTIVITY = 0;
36    public static final int COMPONENT_TAG_BLUETOOTH = 1;
37    public static final int COMPONENT_TAG_WIFI = 2;
38    public static final int COMPONENT_TAG_TELECOM = 3;
39    public static final int COMPONENT_TAG_TELEPHONY = 4;
40
41    public static final int NUMBER_OF_COMPONENTS = 5;
42
43    // Event Tag
44    public static final int TAG_SKIPPED_EVENTS = -1;
45
46    public static final String DATA_KEY_EVENTS_COUNT = "count";
47
48    private IConnectivityMetricsLogger mService;
49
50    private long mServiceUnblockedTimestampMillis = 0;
51    private int mNumSkippedEvents = 0;
52
53    public ConnectivityMetricsLogger() {
54        mService = IConnectivityMetricsLogger.Stub.asInterface(ServiceManager.getService(
55                CONNECTIVITY_METRICS_LOGGER_SERVICE));
56    }
57
58    public void logEvent(long timestamp, int componentTag, int eventTag, Parcelable data) {
59        if (mService == null) {
60            if (DBG) {
61                Log.d(TAG, "logEvent(" + componentTag + "," + eventTag + ") Service not ready");
62            }
63            return;
64        }
65
66        if (mServiceUnblockedTimestampMillis > 0) {
67            if (System.currentTimeMillis() < mServiceUnblockedTimestampMillis) {
68                // Service is throttling events.
69                // Don't send new events because they will be dropped.
70                mNumSkippedEvents++;
71                return;
72            }
73        }
74
75        ConnectivityMetricsEvent skippedEventsEvent = null;
76        if (mNumSkippedEvents > 0) {
77            // Log number of skipped events
78            Bundle b = new Bundle();
79            b.putInt(DATA_KEY_EVENTS_COUNT, mNumSkippedEvents);
80            skippedEventsEvent = new ConnectivityMetricsEvent(mServiceUnblockedTimestampMillis,
81                    componentTag, TAG_SKIPPED_EVENTS, b);
82
83            mServiceUnblockedTimestampMillis = 0;
84        }
85
86        ConnectivityMetricsEvent event = new ConnectivityMetricsEvent(timestamp, componentTag,
87                eventTag, data);
88
89        try {
90            long result;
91            if (skippedEventsEvent == null) {
92                result = mService.logEvent(event);
93            } else {
94                result = mService.logEvents(new ConnectivityMetricsEvent[]
95                        {skippedEventsEvent, event});
96            }
97
98            if (result == 0) {
99                mNumSkippedEvents = 0;
100            } else {
101                mNumSkippedEvents++;
102                if (result > 0) { // events are throttled
103                    mServiceUnblockedTimestampMillis = result;
104                }
105            }
106        } catch (RemoteException e) {
107            Log.e(TAG, "Error logging event " + e.getMessage());
108        }
109    }
110
111    /**
112     * Retrieve events
113     *
114     * @param reference of the last event previously returned. The function will return
115     *                  events following it.
116     *                  If 0 then all events will be returned.
117     *                  After the function call it will contain reference of the
118     *                  last returned event.
119     * @return events
120     */
121    public ConnectivityMetricsEvent[] getEvents(ConnectivityMetricsEvent.Reference reference) {
122        try {
123            return mService.getEvents(reference);
124        } catch (RemoteException ex) {
125            Log.e(TAG, "IConnectivityMetricsLogger.getEvents: " + ex);
126            return null;
127        }
128    }
129
130    /**
131     * Register PendingIntent which will be sent when new events are ready to be retrieved.
132     */
133    public boolean register(PendingIntent newEventsIntent) {
134        try {
135            return mService.register(newEventsIntent);
136        } catch (RemoteException ex) {
137            Log.e(TAG, "IConnectivityMetricsLogger.register: " + ex);
138            return false;
139        }
140    }
141
142    public boolean unregister(PendingIntent newEventsIntent) {
143        try {
144            mService.unregister(newEventsIntent);
145        } catch (RemoteException ex) {
146            Log.e(TAG, "IConnectivityMetricsLogger.unregister: " + ex);
147            return false;
148        }
149
150        return true;
151    }
152}
153