Home | History | Annotate | Download | only in build
      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  */
     16 
     17 package com.android.tradefed.build;
     18 
     19 import com.android.tradefed.device.ITestDevice;
     20 
     21 import java.io.File;
     22 import java.util.Collection;
     23 import java.util.LinkedList;
     24 import java.util.List;
     25 import java.util.Map;
     26 import java.util.Set;
     27 
     28 /**
     29  * A {@link IDeviceBuildInfo} used for over-the-air update testing. It is composed of two device
     30  * builds for {@link ITestDevice}:
     31  * <ul>
     32  * <li>a baseline build image (the build to OTA from).</li>
     33  * <li>a OTA build (a build to OTA to). Should contain necessary build attributes and associated
     34  * OTA package.</li>
     35  * </ul>
     36  * <var>this</var> contains the baseline build, and {@link #getOtaBuild()} returns the OTA
     37  * build.
     38  */
     39 public class OtaDeviceBuildInfo implements IDeviceBuildInfo {
     40 
     41     private static final long serialVersionUID = BuildSerializedVersion.VERSION;
     42     protected IDeviceBuildInfo mOtaBuild;
     43     protected IDeviceBuildInfo mBaselineBuild;
     44     protected boolean mReportTargetBuild = false;
     45 
     46     public void setOtaBuild(IDeviceBuildInfo otaBuild) {
     47         mOtaBuild = otaBuild;
     48     }
     49 
     50     public void setBaselineBuild(IDeviceBuildInfo baselineBuild) {
     51         mBaselineBuild = baselineBuild;
     52     }
     53 
     54     public IDeviceBuildInfo getOtaBuild() {
     55         return mOtaBuild;
     56     }
     57 
     58     public IDeviceBuildInfo getBaselineBuild() {
     59         return mBaselineBuild;
     60     }
     61 
     62     /**
     63      * {@inheritDoc}
     64      */
     65     @Override
     66     public String getBuildId() {
     67         return getReportedBuild().getBuildId();
     68     }
     69 
     70     /**
     71      * {@inheritDoc}
     72      */
     73     @Override
     74     public void setBuildId(String buildId) {
     75         mBaselineBuild.setBuildId(buildId);
     76     }
     77 
     78     /**
     79      * {@inheritDoc}
     80      */
     81     @Override
     82     public String getTestTag() {
     83         return mBaselineBuild.getTestTag();
     84     }
     85 
     86     /**
     87      * {@inheritDoc}
     88      */
     89     @Override
     90     public void setTestTag(String testTag) {
     91         mBaselineBuild.setTestTag(testTag);
     92     }
     93 
     94     /**
     95      * {@inheritDoc}
     96      */
     97     @Override
     98     public String getBuildTargetName() {
     99         return getReportedBuild().getBuildTargetName();
    100     }
    101 
    102     /**
    103      * {@inheritDoc}
    104      */
    105     @Override
    106     public String getBuildFlavor() {
    107         return getReportedBuild().getBuildFlavor();
    108     }
    109 
    110     /**
    111      * {@inheritDoc}
    112      */
    113     @Override
    114     public String getDeviceSerial() {
    115         return mBaselineBuild.getDeviceSerial();
    116     }
    117 
    118     /**
    119      * {@inheritDoc}
    120      */
    121     @Override
    122     public void setBuildFlavor(String buildFlavor) {
    123         mBaselineBuild.setBuildFlavor(buildFlavor);
    124     }
    125 
    126     /**
    127      * {@inheritDoc}
    128      */
    129     @Override
    130     public String getBuildBranch() {
    131         return getReportedBuild().getBuildBranch();
    132     }
    133 
    134     /**
    135      * {@inheritDoc}
    136      */
    137     @Override
    138     public void setBuildBranch(String branch) {
    139         mBaselineBuild.setBuildBranch(branch);
    140     }
    141 
    142     /**
    143      * {@inheritDoc}
    144      */
    145     @Override
    146     public void setDeviceSerial(String serial) {
    147         mBaselineBuild.setDeviceSerial(serial);
    148     }
    149 
    150     /**
    151      * {@inheritDoc}
    152      */
    153     @Override
    154     public Map<String, String> getBuildAttributes() {
    155         return getReportedBuild().getBuildAttributes();
    156     }
    157 
    158     /**
    159      * {@inheritDoc}
    160      */
    161     @Override
    162     public void addBuildAttribute(String attributeName, String attributeValue) {
    163         mBaselineBuild.addBuildAttribute(attributeName, attributeValue);
    164     }
    165 
    166     /** {@inheritDoc} */
    167     @Override
    168     public void setProperties(BuildInfoProperties... properties) {
    169         mBaselineBuild.setProperties(properties);
    170     }
    171 
    172     /** {@inheritDoc} */
    173     @Override
    174     public Set<BuildInfoProperties> getProperties() {
    175         return mBaselineBuild.getProperties();
    176     }
    177 
    178     /**
    179      * {@inheritDoc}
    180      */
    181     @Override
    182     public File getFile(String name) {
    183         return mBaselineBuild.getFile(name);
    184     }
    185 
    186     /** {@inheritDoc} */
    187     @Override
    188     public VersionedFile getVersionedFile(String name) {
    189         return mBaselineBuild.getVersionedFile(name);
    190     }
    191 
    192     /**
    193      * {@inheritDoc}
    194      */
    195     @Override
    196     public String getVersion(String name) {
    197         return mBaselineBuild.getVersion(name);
    198     }
    199 
    200     /**
    201      * {@inheritDoc}
    202      */
    203     @Override
    204     public void setFile(String name, File file, String version) {
    205         mBaselineBuild.setFile(name, file, version);
    206     }
    207 
    208     /**
    209      * {@inheritDoc}
    210      */
    211     @Override
    212     public String getDeviceBuildId() {
    213         return mBaselineBuild.getDeviceBuildId();
    214     }
    215 
    216     /**
    217      * {@inheritDoc}
    218      */
    219     @Override
    220     public String getDeviceBuildFlavor() {
    221         return mBaselineBuild.getDeviceBuildFlavor();
    222     }
    223 
    224     /**
    225      * {@inheritDoc}
    226      */
    227     @Override
    228     public File getDeviceImageFile() {
    229         return mBaselineBuild.getDeviceImageFile();
    230     }
    231 
    232     /**
    233      * {@inheritDoc}
    234      */
    235     @Override
    236     public String getDeviceImageVersion() {
    237         return mBaselineBuild.getDeviceImageVersion();
    238     }
    239 
    240     /**
    241      * {@inheritDoc}
    242      */
    243     @Override
    244     public void setDeviceImageFile(File deviceImageFile, String version) {
    245         mBaselineBuild.setDeviceImageFile(deviceImageFile, version);
    246     }
    247 
    248     /**
    249      * {@inheritDoc}
    250      */
    251     @Override
    252     public File getUserDataImageFile() {
    253         return mBaselineBuild.getUserDataImageFile();
    254     }
    255 
    256     /**
    257      * {@inheritDoc}
    258      */
    259     @Override
    260     public String getUserDataImageVersion() {
    261         return mBaselineBuild.getUserDataImageVersion();
    262     }
    263 
    264     /**
    265      * {@inheritDoc}
    266      */
    267     @Override
    268     public void setUserDataImageFile(File userDataFile, String version) {
    269         mBaselineBuild.setUserDataImageFile(userDataFile, version);
    270     }
    271 
    272     /**
    273      * {@inheritDoc}
    274      */
    275     @Override
    276     public File getTestsDir() {
    277         return mBaselineBuild.getTestsDir();
    278     }
    279 
    280     /**
    281      * {@inheritDoc}
    282      */
    283     @Override
    284     public String getTestsDirVersion() {
    285         return mBaselineBuild.getTestsDirVersion();
    286     }
    287 
    288     /**
    289      * {@inheritDoc}
    290      */
    291     @Override
    292     public void setTestsDir(File testsZipFile, String version) {
    293         mBaselineBuild.setTestsDir(testsZipFile, version);
    294     }
    295 
    296     /**
    297      * {@inheritDoc}
    298      */
    299     @Override
    300     public File getBasebandImageFile() {
    301         return mBaselineBuild.getBasebandImageFile();
    302     }
    303 
    304     /**
    305      * {@inheritDoc}
    306      */
    307     @Override
    308     public String getBasebandVersion() {
    309         return mBaselineBuild.getBasebandVersion();
    310     }
    311 
    312     /**
    313      * {@inheritDoc}
    314      */
    315     @Override
    316     public void setBasebandImage(File basebandFile, String version) {
    317         mBaselineBuild.setBasebandImage(basebandFile, version);
    318     }
    319 
    320     /**
    321      * {@inheritDoc}
    322      */
    323     @Override
    324     public File getBootloaderImageFile() {
    325         return mBaselineBuild.getBootloaderImageFile();
    326     }
    327 
    328     /**
    329      * {@inheritDoc}
    330      */
    331     @Override
    332     public String getBootloaderVersion() {
    333         return mBaselineBuild.getBootloaderVersion();
    334     }
    335 
    336     /**
    337      * {@inheritDoc}
    338      */
    339     @Override
    340     public void setBootloaderImageFile(File bootloaderImgFile, String version) {
    341         mBaselineBuild.setBootloaderImageFile(bootloaderImgFile, version);
    342     }
    343 
    344     /**
    345      * {@inheritDoc}
    346      */
    347     @Override
    348     public File getOtaPackageFile() {
    349         return mBaselineBuild.getOtaPackageFile();
    350     }
    351 
    352     /**
    353      * {@inheritDoc}
    354      */
    355     @Override
    356     public String getOtaPackageVersion() {
    357         return mBaselineBuild.getOtaPackageVersion();
    358     }
    359 
    360     /**
    361      * {@inheritDoc}
    362      */
    363     @Override
    364     public void setOtaPackageFile(File otaFile, String version) {
    365         mBaselineBuild.setOtaPackageFile(otaFile, version);
    366     }
    367 
    368     /**
    369      * {@inheritDoc}
    370      */
    371     @Override
    372     public File getMkbootimgFile() {
    373         return mBaselineBuild.getMkbootimgFile();
    374     }
    375 
    376     /**
    377      * {@inheritDoc}
    378      */
    379     @Override
    380     public String getMkbootimgVersion() {
    381         return mBaselineBuild.getMkbootimgVersion();
    382     }
    383 
    384     /**
    385      * {@inheritDoc}
    386      */
    387     @Override
    388     public void setMkbootimgFile(File mkbootimg, String version) {
    389         mBaselineBuild.setMkbootimgFile(mkbootimg, version);
    390     }
    391 
    392     /**
    393      * {@inheritDoc}
    394      */
    395     @Override
    396     public File getRamdiskFile() {
    397         return mBaselineBuild.getRamdiskFile();
    398     }
    399 
    400     /**
    401      * {@inheritDoc}
    402      */
    403     @Override
    404     public String getRamdiskVersion() {
    405         return mBaselineBuild.getRamdiskVersion();
    406     }
    407 
    408     /**
    409      * {@inheritDoc}
    410      */
    411     @Override
    412     public void setRamdiskFile(File ramdisk, String version) {
    413         mBaselineBuild.setRamdiskFile(ramdisk, version);
    414     }
    415 
    416     /**
    417      * {@inheritDoc}
    418      */
    419     @Override
    420     public void cleanUp() {
    421         mBaselineBuild.cleanUp();
    422         mOtaBuild.cleanUp();
    423     }
    424 
    425     /** {@inheritDoc} */
    426     @Override
    427     public void cleanUp(List<File> doNotDelete) {
    428         mBaselineBuild.cleanUp(doNotDelete);
    429         mOtaBuild.cleanUp(doNotDelete);
    430     }
    431 
    432     /**
    433      * {@inheritDoc}
    434      */
    435     @Override
    436     public IBuildInfo clone() {
    437         OtaDeviceBuildInfo clone = new OtaDeviceBuildInfo();
    438         if (mBaselineBuild != null) {
    439             clone.setBaselineBuild((IDeviceBuildInfo)mBaselineBuild.clone());
    440         }
    441         if (mOtaBuild != null) {
    442             clone.setOtaBuild((IDeviceBuildInfo)mOtaBuild.clone());
    443         }
    444         return clone;
    445     }
    446 
    447     /**
    448      * {@inheritDoc}
    449      */
    450     @Override
    451     public Collection<VersionedFile> getFiles() {
    452         Collection<VersionedFile> combinedFiles = new LinkedList<VersionedFile>();
    453         combinedFiles.addAll(mBaselineBuild.getFiles());
    454         combinedFiles.addAll(mOtaBuild.getFiles());
    455         return combinedFiles;
    456     }
    457 
    458     public void setReportTargetBuild(boolean downgrade) {
    459         mReportTargetBuild = downgrade;
    460     }
    461 
    462     protected IDeviceBuildInfo getReportedBuild() {
    463         return (mReportTargetBuild ? mOtaBuild : mBaselineBuild);
    464     }
    465 }
    466