1/*
2 * Copyright (C) 2012 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 com.android.mail.utils;
17
18import android.content.Context;
19import android.content.Intent;
20import android.content.IntentFilter;
21
22/**
23 * Holds the storage state of the system. Allows for registering a single handler which can
24 * adjust application state to deal with STORAGE_LOW and STORAGE_OK state:
25 * Reference: {@link Intent#ACTION_DEVICE_STORAGE_LOW}, {@link Intent#ACTION_DEVICE_STORAGE_OK}
26 */
27public final class StorageLowState {
28    /**
29     * Methods that are called when a device enters/leaves storage low mode.
30     */
31    public interface LowStorageHandler {
32        /**
33         * Method to be called when the device enters storage low mode.
34         */
35        void onStorageLow();
36
37        /**
38         * Method to be run when the device recovers from storage low mode.
39         */
40        void onStorageOk();
41    }
42    /** True if the system has entered STORAGE_LOW state. */
43    private static boolean sIsStorageLow = false;
44    /** If non-null, this represents a handler that is notified of changes to state. */
45    private static LowStorageHandler sHandler = null;
46
47    /** Private constructor to avoid class instantiation. */
48    private StorageLowState() {
49        // Do nothing.
50    }
51
52    /**
53     * Checks if the device is in storage low state. If the state changes, the handler is notified
54     * of it. The handler is not notified if the state remains the same as before.
55     */
56    public static void checkStorageLowMode(Context context) {
57        // Identify if we are in low storage mode. This works because storage low is a sticky
58        // intent, so we are guaranteed a non-null intent if that broadcast was sent and not
59        // cleared subsequently.
60        final IntentFilter filter = new IntentFilter(Intent.ACTION_DEVICE_STORAGE_LOW);
61        final Intent result = context.registerReceiver(null, filter);
62        setIsStorageLow(result != null);
63    }
64
65    /**
66     * Notifies {@link StorageLowState} that the device has entered storage low state.
67     */
68    public static void setIsStorageLow(boolean newValue) {
69        if (sIsStorageLow == newValue) {
70            // The state is unchanged, nothing to do.
71            return;
72        }
73        sIsStorageLow = newValue;
74        if (sHandler == null) {
75            return;
76        }
77        if (newValue) {
78            sHandler.onStorageLow();
79        } else {
80            sHandler.onStorageOk();
81        }
82    }
83
84    /**
85     * Sets the handler that can adjust application state to deal with storage low and
86     * storage ok intents.
87     * Reference: {@link Intent#ACTION_DEVICE_STORAGE_LOW}, {@link Intent#ACTION_DEVICE_STORAGE_OK}
88     * @param in a handler that can deal with changes to the storage state.
89     */
90    public static void registerHandler(LowStorageHandler in) {
91        sHandler = in;
92        // If we are currently in low storage mode, let the handler deal with it immediately.
93        if (sIsStorageLow) {
94            sHandler.onStorageLow();
95        }
96    }
97}
98